asciidoclint 0.5.0

package/dist/rules/AD032.js

@@ -0,0 +1,81 @@
+import { blockDelimiterType, isAsciiDocAnchorLine, isAsciiDocBlockAttributeLine, isAsciiDocSectionTitleLine, isAsciiDocTitleLine, isBlockDelimiter, isLineInProtectedBlock, } from "./utils.js";
+export const AD032 = {
+    id: "AD032",
+    alias: "blank-before-block",
+    description: "Structural block delimiters should be preceded by a blank line",
+    tags: ["cleanup", "blocks"],
+    parser: "text",
+    docs: {
+        summary: "Delimited blocks should be separated from preceding text so Asciidoctor can parse the intended block boundary.",
+        fixability: "safe",
+        badExamples: [{ code: "Text\n====\nexample\n====" }],
+        goodExamples: [{ code: "Text\n\n====\nexample\n====" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            const openDelimiters = [];
+            for (let index = 1; index < file.lines.length; index += 1) {
+                const line = file.lines[index] ?? "";
+                const previous = file.lines[index - 1] ?? "";
+                const delimiter = line.trim();
+                if (!isBlockDelimiter(delimiter)) {
+                    continue;
+                }
+                const delimiterType = blockDelimiterType(delimiter);
+                if (isLineInProtectedBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                if (delimiterType === "table" && isKnownTableClosingDelimiter(document, file.file, index + 1)) {
+                    continue;
+                }
+                if (delimiterType === "table" && isTableCellLine(previous, delimiter)) {
+                    continue;
+                }
+                const isClosing = openDelimiters[openDelimiters.length - 1] === delimiter;
+                if (isClosing) {
+                    openDelimiters.pop();
+                    continue;
+                }
+                openDelimiters.push(delimiter);
+                if (previous.trim() !== ""
+                    && !isBlockDelimiter(previous.trim())
+                    && previous.trim() !== "+"
+                    && !isAsciiDocBlockAttributeLine(previous)
+                    && !isAsciiDocTitleLine(previous)
+                    && !isAsciiDocSectionTitleLine(previous)
+                    && !isAsciiDocAnchorLine(previous)) {
+                    const lineNumber = index + 1;
+                    const severity = canBeParsedAsSetextSectionDelimiter(delimiter) ? "error" : "warning";
+                    onError({
+                        severity,
+                        message: "Block delimiter 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 isTableCellLine(line, delimiter = "|===") {
+    const trimmed = line.trim();
+    return trimmed.startsWith(delimiter[0] ?? "|") && trimmed !== delimiter;
+}
+function isKnownTableClosingDelimiter(document, file, line) {
+    return document.blocks.some((block) => (block.type === "table"
+        && block.range.end?.file === file
+        && block.range.end.line === line));
+}
+function canBeParsedAsSetextSectionDelimiter(delimiter) {
+    return /^={4,}$/.test(delimiter) || /^-{4,}$/.test(delimiter) || /^\+{4,}$/.test(delimiter);
+}

package/dist/rules/AD034.d.ts

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

package/dist/rules/AD034.js

@@ -0,0 +1,50 @@
+import { isLineInProtectedBlock, isLineInTableBlock } from "./utils.js";
+export const AD034 = {
+    id: "AD034",
+    alias: "no-hard-tabs",
+    description: "Lines should not contain hard tabs",
+    tags: ["cleanup", "whitespace"],
+    parser: "text",
+    docs: {
+        summary: "Use spaces instead of hard tab characters.",
+        rationale: "Hard tabs in prose and structural markup render inconsistently across editors, terminals, and generated output.",
+        fixability: "safe",
+        fixHelper: "Replace hard tabs in prose or structural markup with spaces. Keep tabs inside TSV tables and protected/verbatim content when they are intentional data.",
+        badExamples: [{ code: "*\tTabbed list item" }],
+        goodExamples: [{ code: "* Tabbed list item" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                const lineNumber = index + 1;
+                if (!line.includes("\t")
+                    || isLineInProtectedBlock(document, file.file, lineNumber)
+                    || isLineInTableBlock(document, file.file, lineNumber)) {
+                    continue;
+                }
+                for (const match of line.matchAll(/\t/g)) {
+                    const column = (match.index ?? 0) + 1;
+                    onError({
+                        severity: "warning",
+                        message: "Line contains a hard tab",
+                        range: {
+                            start: { file: file.file, line: lineNumber, column },
+                            end: { file: file.file, line: lineNumber, column: column + 1 },
+                        },
+                        fix: {
+                            applicability: "safe",
+                            edits: [{
+                                    file: file.file,
+                                    range: {
+                                        start: { file: file.file, line: lineNumber, column },
+                                        end: { file: file.file, line: lineNumber, column: column + 1 },
+                                    },
+                                    replacement: " ",
+                                }],
+                        },
+                    });
+                }
+            }
+        }
+    },
+};

package/dist/rules/AD035.d.ts

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

package/dist/rules/AD035.js

@@ -0,0 +1,77 @@
+import { blockDelimiterType, isAsciiDocAnchorLine, isAsciiDocBlockAttributeLine, isAsciiDocTitleLine, isBlockDelimiter, isLineComment, isLineInProtectedBlock, isLineInTableBlock, isListMarkerLine } from "./utils.js";
+export const AD035 = {
+    id: "AD035",
+    alias: "blank-after-block",
+    description: "Structural block delimiters should be followed by a blank line",
+    tags: ["cleanup", "blocks"],
+    parser: "text",
+    docs: {
+        summary: "Delimited blocks are easier to parse and read when separated from following paragraph text.",
+        fixability: "safe",
+        badExamples: [{ code: "====\nexample\n====\nText" }],
+        goodExamples: [{ code: "====\nexample\n====\n\nText" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            const openDelimiters = [];
+            for (let index = 0; index < file.lines.length - 1; index += 1) {
+                const line = file.lines[index] ?? "";
+                const next = file.lines[index + 1] ?? "";
+                const delimiter = line.trim();
+                if (!isBlockDelimiter(delimiter)) {
+                    continue;
+                }
+                const delimiterType = blockDelimiterType(delimiter);
+                if (isLineInProtectedBlock(document, file.file, index + 1) || isLineInTableBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                const isClosing = openDelimiters[openDelimiters.length - 1] === delimiter;
+                if (!isClosing) {
+                    openDelimiters.push(delimiter);
+                    continue;
+                }
+                openDelimiters.pop();
+                if (delimiterType === "table" && isTableCellLine(next, delimiter)) {
+                    continue;
+                }
+                if (next.trim() === ""
+                    || next.trim() === "+"
+                    || next.trim() === "{nbsp}"
+                    || /^=+\s+\S/.test(next.trim())
+                    || isBlockDelimiter(next.trim())
+                    || isListMarkerLine(next)
+                    || isLineComment(next)
+                    || isConditionalDirective(next)
+                    || isAsciiDocAnchorLine(next)
+                    || isAsciiDocTitleLine(next)
+                    || isAsciiDocBlockAttributeLine(next)) {
+                    continue;
+                }
+                const lineNumber = index + 1;
+                onError({
+                    severity: "warning",
+                    message: "Block delimiter should be followed by a blank line",
+                    range: { start: { file: file.file, line: lineNumber, column: line.length + 1 } },
+                    fix: {
+                        applicability: "safe",
+                        edits: [{
+                                file: file.file,
+                                range: {
+                                    start: { file: file.file, line: lineNumber + 1, column: 1 },
+                                    end: { file: file.file, line: lineNumber + 1, column: 1 },
+                                },
+                                replacement: "\n",
+                            }],
+                    },
+                });
+            }
+        }
+    },
+};
+function isTableCellLine(line, delimiter = "|===") {
+    const trimmed = line.trim();
+    return trimmed.startsWith(delimiter[0] ?? "|") && trimmed !== delimiter;
+}
+function isConditionalDirective(line) {
+    return /^(?:ifdef|ifndef|ifeval|endif)::/.test(line.trim());
+}

package/dist/rules/AD036.d.ts

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

package/dist/rules/AD036.js

@@ -0,0 +1,34 @@
+import { isLineInProtectedBlock, isLineInTableBlock, isListMarkerResidueLine } from "./utils.js";
+export const AD036 = {
+    id: "AD036",
+    alias: "list-marker-residue",
+    description: "Standalone list marker residue should be removed or completed",
+    tags: ["cleanup", "lists"],
+    parser: "text",
+    docs: {
+        summary: "A line containing only a list marker renders as visible text instead of a list item.",
+        rationale: "AsciiDoc list items require principal text after the marker. Marker-only lines are usually conversion residue or unfinished content.",
+        fixability: "no",
+        fixHelper: "Remove the marker residue, add the missing list item text, or use {empty} plus a list continuation when the list item intentionally has only attached block content.",
+        badExamples: [{ code: "*\nText" }],
+        goodExamples: [{ code: "* Text" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                const lineNumber = index + 1;
+                if (!isListMarkerResidueLine(line)
+                    || isLineInProtectedBlock(document, file.file, lineNumber)
+                    || isLineInTableBlock(document, file.file, lineNumber)) {
+                    continue;
+                }
+                onError({
+                    severity: "warning",
+                    message: "Standalone list marker renders as text",
+                    range: { start: { file: file.file, line: lineNumber, column: line.search(/\S/) + 1 } },
+                    fixHelper: "Remove the marker residue, add the missing list item text, or use {empty} plus a list continuation for a list item that intentionally has only attached block content.",
+                });
+            }
+        }
+    },
+};

package/dist/rules/AD037.d.ts

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

package/dist/rules/AD037.js

@@ -0,0 +1,34 @@
+import { isLineInProtectedBlock, isLineInTableBlock, isUnderlineResidueLine } from "./utils.js";
+export const AD037 = {
+    id: "AD037",
+    alias: "underline-residue",
+    description: "Standalone underline residue should be removed or converted",
+    tags: ["cleanup", "conversion"],
+    parser: "text",
+    docs: {
+        summary: "A standalone three-underscore line is usually leftover underline styling from converted documents.",
+        rationale: "AsciiDoc uses four or more underscores for quote block delimiters, but exactly three underscores are not document structure and render as visible residue.",
+        fixability: "no",
+        fixHelper: "Remove the three-underscore residue, or convert the intended underlined text to AsciiDoc emphasis such as _text_. Keep four or more underscores only when they are matching quote block delimiters.",
+        badExamples: [{ code: "Important\n___" }],
+        goodExamples: [{ code: "_Important_" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                const lineNumber = index + 1;
+                if (!isUnderlineResidueLine(line)
+                    || isLineInProtectedBlock(document, file.file, lineNumber)
+                    || isLineInTableBlock(document, file.file, lineNumber)) {
+                    continue;
+                }
+                onError({
+                    severity: "warning",
+                    message: "Standalone three-underscore residue should be removed",
+                    range: { start: { file: file.file, line: lineNumber, column: line.search(/\S/) + 1 } },
+                    fixHelper: "Remove the three-underscore residue or convert the intended underlined text to AsciiDoc emphasis.",
+                });
+            }
+        }
+    },
+};

package/dist/rules/AD039.d.ts

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

package/dist/rules/AD039.js

@@ -0,0 +1,58 @@
+import { isLineComment, isLineInCommentParagraph, isLineInProtectedBlock, isLineInTableBlock } from "./utils.js";
+export const AD039 = {
+    id: "AD039",
+    alias: "punctuation-passthrough-residue",
+    description: "Safe punctuation passthrough residue should be removed",
+    tags: ["cleanup", "conversion"],
+    parser: "text",
+    docs: {
+        summary: "Inline passthrough wrappers around safe punctuation are usually conversion residue.",
+        rationale: "AsciiDoc supports inline passthroughs, but wrappers around _, [, ], <, >, and | are common conversion residue when they appear in ordinary source text.",
+        fixability: "safe",
+        fixHelper: "Replace the passthrough-wrapped punctuation with the literal character when AD039 reports it.",
+        badExamples: [{ code: "SE++_++KSLT and SE++[++0-4++]++" }],
+        goodExamples: [{ code: "SE_KSLT and SE[0-4]" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                const lineNumber = index + 1;
+                if (isLineComment(line) || isLineInProtectedBlock(document, file.file, lineNumber) || isLineInCommentParagraph(file.lines, index)) {
+                    continue;
+                }
+                for (const match of line.matchAll(/\+\+([_[\]<>|])\+\+/g)) {
+                    const replacement = match[1] ?? "";
+                    if ((replacement === "|" && isLineInTableBlock(document, file.file, lineNumber))
+                        || (["[", "]"].includes(replacement) && isStandaloneBracketPassthroughLine(line))) {
+                        continue;
+                    }
+                    const column = (match.index ?? 0) + 1;
+                    const endColumn = column + match[0].length;
+                    onError({
+                        severity: "warning",
+                        message: "Punctuation passthrough conversion residue should be removed",
+                        range: {
+                            start: { file: file.file, line: lineNumber, column },
+                            end: { file: file.file, line: lineNumber, column: endColumn },
+                        },
+                        fixHelper: `Replace ${match[0]} with ${replacement}.`,
+                        fix: {
+                            applicability: "safe",
+                            edits: [{
+                                    file: file.file,
+                                    range: {
+                                        start: { file: file.file, line: lineNumber, column },
+                                        end: { file: file.file, line: lineNumber, column: endColumn },
+                                    },
+                                    replacement,
+                                }],
+                        },
+                    });
+                }
+            }
+        }
+    },
+};
+function isStandaloneBracketPassthroughLine(line) {
+    return /^\s*\+\+\[\+\+[^+\n]*\+\+\]\+\+\s*$/.test(line);
+}

package/dist/rules/AD040.d.ts

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

package/dist/rules/AD040.js

@@ -0,0 +1,56 @@
+import { isLineComment, isLineInCommentParagraph, isLineInProtectedBlock } from "./utils.js";
+export const AD040 = {
+    id: "AD040",
+    alias: "html-link-text-residue",
+    description: "Link text should not contain raw HTML or XML residue",
+    tags: ["cleanup", "links", "conversion"],
+    parser: "text",
+    docs: {
+        summary: "Visible link text should not contain raw HTML or XML fragments.",
+        rationale: "Raw markup inside link text is escaped by Asciidoctor and becomes visible label text, which is usually conversion residue.",
+        fixability: "no",
+        fixHelper: "Keep only the intended human-readable link text and remove raw markup fragments from the label.",
+        badExamples: [{ code: "link:https://example.com[++<span>Example</span>++]" }],
+        goodExamples: [{ code: "link:https://example.com[Example]" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                const lineNumber = index + 1;
+                if (isLineComment(line)
+                    || isLineInProtectedBlock(document, file.file, lineNumber)
+                    || isLineInCommentParagraph(file.lines, index)) {
+                    continue;
+                }
+                for (const match of linkLabelMarkupResidueMatches(line)) {
+                    onError({
+                        severity: "warning",
+                        message: "Link text should not contain raw HTML or XML residue",
+                        range: {
+                            start: { file: file.file, line: lineNumber, column: match.column },
+                            end: { file: file.file, line: lineNumber, column: match.endColumn },
+                        },
+                        fixHelper: "Keep only the intended human-readable link text and remove raw markup fragments from the label.",
+                    });
+                }
+            }
+        }
+    },
+};
+function linkLabelMarkupResidueMatches(line) {
+    const matches = [];
+    const macroPattern = /\b(?:link|xref):[^\s[]+\[((?:[^\]\\]|\\.|\][^\s])*?)]/g;
+    for (const macro of line.matchAll(macroPattern)) {
+        if (macro.index === undefined) {
+            continue;
+        }
+        const label = macro[1] ?? "";
+        const markup = label.match(/\+{2,3}<\/?[A-Za-z][^>\]\n]*>\+{2,3}|<\/?[A-Za-z][^>\]\n]*>/);
+        if (!markup || markup.index === undefined) {
+            continue;
+        }
+        const column = macro.index + macro[0].indexOf(label) + markup.index + 1;
+        matches.push({ column, endColumn: column + markup[0].length });
+    }
+    return matches;
+}

package/dist/rules/AD041.d.ts

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

package/dist/rules/AD041.js

@@ -0,0 +1,66 @@
+import { isLineComment, isLineInCommentParagraph, isLineInProtectedBlock, isLineInTableBlock, listMarkerContent } from "./utils.js";
+const spacedFormattingPatterns = [
+    /(^|[^\w])([*_])\s+[^\d\s][^\n]*?\s+\2(?=\s|$|[.,;:!?])/,
+    /(^|[^\w])([*_])\S[^\n]*?\s+\2(?=\s|$|[.,;:!?])/,
+    /`\+\s+\S[^`]*?\s+\+`/,
+];
+const literalMonospacePatternIndex = 2;
+export const AD041 = {
+    id: "AD041",
+    alias: "no-space-in-inline-formatting",
+    description: "Inline formatting markers should not contain inner spaces",
+    tags: ["cleanup", "format", "inline"],
+    parser: "text",
+    docs: {
+        summary: "Flag spaces just inside AsciiDoc emphasis, strong, or monospace markers.",
+        rationale: "AsciiDoc inline formatting is delimiter-sensitive; inner spaces often leave the intended formatting markers visible in rendered output.",
+        fixability: "no",
+        fixHelper: "Move spaces outside constrained formatting markers, or use the correct unconstrained pair when spaces must remain inside the formatted span.",
+        badExamples: [{ code: "This is * important * text and `+ code +` should be fixed." }],
+        goodExamples: [{ code: "This is *important* text and `+code+` should be fixed." }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                if (isLineComment(line)
+                    || isLineInProtectedBlock(document, file.file, index + 1)
+                    || isLineInCommentParagraph(file.lines, index)
+                    || isLineInTableBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                const masked = maskRenderedInlineSpans(maskInlineMacroSpans(line));
+                const content = listMarkerContent(masked);
+                const matchEntry = spacedFormattingPatterns
+                    .map((pattern, patternIndex) => ({ match: content.content.match(pattern), patternIndex }))
+                    .find((entry) => entry.match?.index !== undefined);
+                const match = matchEntry?.match;
+                if (!match || match.index === undefined) {
+                    continue;
+                }
+                if (matchEntry.patternIndex !== literalMonospacePatternIndex && isLikelyFormulaText(match[0])) {
+                    continue;
+                }
+                onError({
+                    severity: "warning",
+                    message: "Inline formatting marker contains inner spaces",
+                    range: { start: { file: file.file, line: index + 1, column: content.offset + match.index + 1 } },
+                    fixHelper: "Move spaces outside the AsciiDoc formatting markers.",
+                });
+            }
+        }
+    },
+};
+function maskInlineMacroSpans(line) {
+    return line
+        .replace(/`(?!\+)[^`]*`/g, (match) => "x".repeat(match.length))
+        .replace(/\b[A-Za-z][A-Za-z0-9_-]*:\[[^\]]*]/g, (match) => "x".repeat(match.length));
+}
+function maskRenderedInlineSpans(line) {
+    return line
+        .replace(/\*_[^\n]*?_\*/g, (match) => "x".repeat(match.length))
+        .replace(/_\*[^\n]*?\*_/g, (match) => "x".repeat(match.length))
+        .replace(/\*\*[^\n]*?\*\*/g, (match) => "x".repeat(match.length));
+}
+function isLikelyFormulaText(text) {
+    return /[=+\/~^]|\b(?:mod|div)\b|\d/.test(text);
+}

package/dist/rules/AD042.d.ts

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

package/dist/rules/AD042.js

@@ -0,0 +1,62 @@
+import { isLineInProtectedBlock } from "./utils.js";
+const xrefPattern = /(?<!\\)\bxref:([^\s\[]+)\[([^\]]*)]/g;
+const adocTargetPattern = /\.a(?:scii)?doc(?:#|$)/i;
+const namedAttributePattern = /^[A-Za-z_][\w.-]*\s*=/;
+function firstAttribute(attrlist) {
+    let quote;
+    for (let index = 0; index < attrlist.length; index += 1) {
+        const char = attrlist[index];
+        if ((char === '"' || char === "'") && attrlist[index - 1] !== "\\") {
+            quote = quote === char ? undefined : quote ?? char;
+        }
+        else if (char === "," && quote === undefined) {
+            return attrlist.slice(0, index).trim();
+        }
+    }
+    return attrlist.trim();
+}
+function hasExplicitText(attrlist) {
+    const first = firstAttribute(attrlist);
+    return first.length > 0 && !namedAttributePattern.test(first);
+}
+export const AD042 = {
+    id: "AD042",
+    alias: "interdocument-xref-text",
+    description: "Interdocument xrefs should provide explicit link text",
+    tags: ["xref", "links", "accessibility"],
+    parser: "text",
+    docs: {
+        summary: "Flag interdocument xref macros that omit the first positional link-text attribute.",
+        rationale: "AsciiDoc allows intradocument xrefs to derive text from the target, but Asciidoctor documents interdocument xref text as required. When omitted, Asciidoctor.js renders a weak converted filename label.",
+        fixability: "no",
+        fixHelper: "Add human-readable text as the first xref attribute, before named attributes such as window or xrefstyle.",
+        badExamples: [{ code: "See xref:chapter.adoc[] and xref:chapter.adoc#overview[window=_blank]." }],
+        goodExamples: [
+            {
+                code: "See xref:chapter.adoc[Chapter overview] and xref:chapter.adoc#overview[Overview,window=_blank].",
+            },
+        ],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                if (isLineInProtectedBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                for (const match of line.matchAll(xrefPattern)) {
+                    const target = match[1] ?? "";
+                    const attrlist = match[2] ?? "";
+                    if (!adocTargetPattern.test(target) || hasExplicitText(attrlist)) {
+                        continue;
+                    }
+                    onError({
+                        severity: "warning",
+                        message: "Interdocument xref is missing explicit link text",
+                        range: { start: { file: file.file, line: index + 1, column: (match.index ?? 0) + 1 } },
+                        fixHelper: `Add descriptive text to the xref for ${target}.`,
+                    });
+                }
+            }
+        }
+    },
+};

package/dist/rules/AD043.d.ts

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

package/dist/rules/AD043.js

@@ -0,0 +1,30 @@
+import { isLineInProtectedBlock } from "./utils.js";
+export const AD043 = {
+    id: "AD043",
+    alias: "section-title-start-left",
+    description: "Section title syntax should start at the beginning of the line",
+    tags: ["headings", "structure"],
+    parser: "text",
+    docs: {
+        summary: "Flag indented lines that look like AsciiDoc section titles.",
+        rationale: "AsciiDoc section titles are block starts aligned to the left margin. An indented section-title-looking line is valid literal content, but it is not part of the section tree.",
+        fixability: "no",
+        fixHelper: "If the line is intended to be a section title, remove the leading indentation. If it is intended as literal example text, put it in an explicit listing or literal block.",
+        badExamples: [{ code: "= Title\n\n == Intended Section\n\n ## Intended Markdown-Compatible Section\n\nText." }],
+        goodExamples: [{ code: "= Title\n\n== Intended Section\n\n## Intended Markdown-Compatible Section\n\nText." }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                if (!/^[ \t]+(?:={1,6}|#{1,6})[ \t]+\S/.test(line) || isLineInProtectedBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                onError({
+                    severity: "warning",
+                    message: "Indented section-title-looking line renders as literal text, not as a section",
+                    range: { start: { file: file.file, line: index + 1, column: 1 } },
+                });
+            }
+        }
+    },
+};

package/dist/rules/AD044.d.ts

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

package/dist/rules/AD044.js

@@ -0,0 +1,54 @@
+import { isLineInProtectedBlock } from "./utils.js";
+const localAdocLinkPattern = /(^|[^\w:\\])link:(?!:)([^\s\[]+\.(?:adoc|asciidoc|asc)(?:#[^\s\[]*)?)\[[^\]]*]/gi;
+export const AD044 = {
+    id: "AD044",
+    alias: "local-adoc-link",
+    description: "Local AsciiDoc files should be referenced with xref, not link",
+    tags: ["core", "links", "xref"],
+    parser: "text",
+    docs: {
+        summary: "Use xref: for local AsciiDoc source files so converted output targets are rewritten correctly.",
+        rationale: "Asciidoctor documents link: for relative non-AsciiDoc files and xref: for relative AsciiDoc files. link:chapter.adoc[] renders as chapter.adoc, while xref:chapter.adoc[] renders as the converted output target such as chapter.html.",
+        fixability: "unsafe",
+        fixHelper: "Change link:file.adoc#id[text] to xref:file.adoc#id[text] when the target is an AsciiDoc source file and does not use URL query semantics.",
+        badExamples: [{ code: "link:chapter.adoc#setup[Setup]" }],
+        goodExamples: [{ code: "xref:chapter.adoc#setup[Setup]" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                if (isLineInProtectedBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                for (const match of line.matchAll(localAdocLinkPattern)) {
+                    const prefixLength = match[1]?.length ?? 0;
+                    const target = match[2] ?? "";
+                    if (isExternalTarget(target)) {
+                        continue;
+                    }
+                    const column = (match.index ?? 0) + prefixLength + 1;
+                    onError({
+                        severity: "warning",
+                        message: `Local AsciiDoc link should use xref: ${target}`,
+                        range: { start: { file: file.file, line: index + 1, column } },
+                        fixHelper: "Use xref: for local AsciiDoc source files so the target is rewritten to the converted output path.",
+                        fix: {
+                            applicability: "unsafe",
+                            edits: [{
+                                    file: file.file,
+                                    range: {
+                                        start: { file: file.file, line: index + 1, column },
+                                        end: { file: file.file, line: index + 1, column: column + "link:".length },
+                                    },
+                                    replacement: "xref:",
+                                }],
+                        },
+                    });
+                }
+            }
+        }
+    },
+};
+function isExternalTarget(target) {
+    return /^[a-z][a-z0-9+.-]*:/i.test(target) || target.startsWith("mailto:");
+}