eslint-plugin-markdown-preferences 0.25.0 → 0.26.1

package/README.md

@@ -13,18 +13,24 @@ A specialized ESLint plugin that helps enforce consistent writing style and form
 
 ## 📛 Features
 
-- **⚡ Effortless automation** - Transform your Markdown with auto-fixing that handles formatting, casing, and style consistency automatically
-- **📖 Professional documentation** - Enforce consistent headings, table headers, and organize link definitions for enterprise-ready documentation
-- **🎨 Clean formatting** - Remove trailing spaces, control line breaks, standardize code blocks, and ensure consistent list numbering for polished output
-- **⚙️ Flexible customization** - Configure casing styles (Title Case, Sentence case), code block languages, emoji notation, and more with extensive options
-
-**Try it live:** Check out the [Online Demo](https://eslint-online-playground.netlify.app/#eslint-plugin-markdown-preferences) to see the plugin in action!
+- 📝 **Comprehensive style enforcement**\
+  Unifies document expression and description style: heading casing, table header casing, inline code/link usage, emoji notation, and more.
+- 🧩 **Notation and formatting consistency**\
+  Standardizes Markdown notation: list markers, code fences, link/reference style, thematic breaks, and table formatting.
+- 🎨 **Whitespace and decorative rules**\
+  Controls indentation, spacing, line breaks, trailing spaces, and decorative elements for clean, readable Markdown.
+- 🔧 **Auto-fix support**\
+  Most rules support ESLint's `--fix` option for effortless formatting and correction.
+- ⚙️ **Flexible configuration**\
+  Provides both "recommended" and "standard" configs, and allows you to finely customize formatting and rules to suit your preferences and Markdown style.
+- 🌐 **Live demo & documentation**\
+  Try it instantly in the [Online Demo](https://eslint-online-playground.netlify.app/#eslint-plugin-markdown-preferences) and see [full documentation][documentation site].
 
 <!--DOCS_IGNORE_START-->
 
 ## 📖 Documentation
 
-For detailed usage instructions, rule configurations, and examples, visit our comprehensive [documentation site](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/).
+For detailed usage instructions, rule configurations, and examples, visit our comprehensive [documentation site].
 
 ## 💿 Installation
 
@@ -205,5 +211,6 @@ Please use GitHub's Issues/PRs.
 
 See the [LICENSE](./LICENSE) file for license rights and limitations (MIT).
 
+[documentation site]: https://ota-meshi.github.io/eslint-plugin-markdown-preferences/
 [npm-package]: https://www.npmjs.com/package/eslint-plugin-markdown-preferences
 [npmtrends]: http://www.npmtrends.com/eslint-plugin-markdown-preferences

package/lib/index.d.ts

@@ -49,7 +49,7 @@ interface RuleOptions {
    * require link definitions and footnote definitions to be placed at the end of the document
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html
    */
-  'markdown-preferences/definitions-last'?: Linter.RuleEntry<[]>;
+  'markdown-preferences/definitions-last'?: Linter.RuleEntry<MarkdownPreferencesDefinitionsLast>;
   /**
    * enforce consistent emoji notation style in Markdown files.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emoji-notation.html
@@ -275,6 +275,16 @@ type MarkdownPreferencesCodeFenceLength = [] | [{
 type MarkdownPreferencesCodeFenceStyle = [] | [{
   style?: ("backtick" | "tilde");
 }];
+type MarkdownPreferencesDefinitionsLast = [] | [{
+  linkDefinitionPlacement?: {
+    referencedFromSingleSection?: ("document-last" | "section-last");
+    referencedFromMultipleSections?: ("document-last" | "first-reference-section-last" | "last-reference-section-last");
+  };
+  footnoteDefinitionPlacement?: {
+    referencedFromSingleSection?: ("document-last" | "section-last");
+    referencedFromMultipleSections?: ("document-last" | "first-reference-section-last" | "last-reference-section-last");
+  };
+}];
 type MarkdownPreferencesEmojiNotation = [] | [{
   prefer?: ("unicode" | "colon");
   ignoreUnknown?: boolean;
@@ -488,7 +498,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.25.0";
+declare const version: "0.26.1";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -36,6 +36,26 @@ function getParent(sourceCode, node) {
 	return sourceCode.getParent(node);
 }
 /**
+* Get the previous sibling of a node.
+*/
+function getPrevSibling(sourceCode, node) {
+	const parent = getParent(sourceCode, node);
+	if (!parent) return null;
+	const index = parent.children.indexOf(node);
+	if (index <= 0) return null;
+	return parent.children[index - 1];
+}
+/**
+* Get the next sibling of a node.
+*/
+function getNextSibling(sourceCode, node) {
+	const parent = getParent(sourceCode, node);
+	if (!parent) return null;
+	const index = parent.children.indexOf(node);
+	if (index < 0 || index >= parent.children.length - 1) return null;
+	return parent.children[index + 1];
+}
+/**
 * Get the kind of heading.
 */
 function getHeadingKind(sourceCode, node) {
@@ -798,7 +818,7 @@ function getOtherMarker(unavailableMarker) {
 /**
 * Parse rule options.
 */
-function parseOptions$4(options) {
+function parseOptions$5(options) {
 	const primary = options.primary || "-";
 	const secondary = options.secondary || getOtherMarker(primary);
 	if (primary === secondary) throw new Error(`\`primary\` and \`secondary\` cannot be the same (primary: "${primary}", secondary: "${secondary}").`);
@@ -866,7 +886,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$4(context.options[0] || {});
+		const options = parseOptions$5(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -1307,6 +1327,23 @@ var code_fence_style_default = createRule("code-fence-style", {
 
 //#endregion
 //#region src/rules/definitions-last.ts
+/**
+* Parse options with defaults.
+*/
+function parseOptions$4(options) {
+	const linkDefinitionPlacement = {
+		referencedFromSingleSection: options?.linkDefinitionPlacement?.referencedFromSingleSection || "document-last",
+		referencedFromMultipleSections: options?.linkDefinitionPlacement?.referencedFromMultipleSections || "document-last"
+	};
+	const footnoteDefinitionPlacement = {
+		referencedFromSingleSection: options?.footnoteDefinitionPlacement?.referencedFromSingleSection || "document-last",
+		referencedFromMultipleSections: options?.footnoteDefinitionPlacement?.referencedFromMultipleSections || "document-last"
+	};
+	return {
+		linkDefinitionPlacement,
+		footnoteDefinitionPlacement
+	};
+}
 var definitions_last_default = createRule("definitions-last", {
 	meta: {
 		type: "layout",
@@ -1317,31 +1354,243 @@ var definitions_last_default = createRule("definitions-last", {
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		schema: [],
-		messages: {}
+		schema: [{
+			type: "object",
+			properties: {
+				linkDefinitionPlacement: {
+					type: "object",
+					properties: {
+						referencedFromSingleSection: {
+							type: "string",
+							enum: ["document-last", "section-last"]
+						},
+						referencedFromMultipleSections: {
+							type: "string",
+							enum: [
+								"document-last",
+								"first-reference-section-last",
+								"last-reference-section-last"
+							]
+						}
+					},
+					additionalProperties: false
+				},
+				footnoteDefinitionPlacement: {
+					type: "object",
+					properties: {
+						referencedFromSingleSection: {
+							type: "string",
+							enum: ["document-last", "section-last"]
+						},
+						referencedFromMultipleSections: {
+							type: "string",
+							enum: [
+								"document-last",
+								"first-reference-section-last",
+								"last-reference-section-last"
+							]
+						}
+					},
+					additionalProperties: false
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			definitionsDocumentLast: "Definition or footnote definition should be placed at the end of the document.",
+			definitionsSectionLast: "Definition or footnote definition should be placed at the end of the section ({{at}}).",
+			definitionsLastSectionLast: "Definition or footnote definition should be placed at the end of the last section (the end of the document)."
+		}
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const lastNonDefinition = sourceCode.ast.children.findLast((node) => node.type !== "definition" && node.type !== "footnoteDefinition" && !(node.type === "html" && (node.value.startsWith("<!--") || node.value.startsWith("<script") || node.value.startsWith("<style"))));
-		if (!lastNonDefinition) return {};
-		const lastNonDefinitionRange = sourceCode.getRange(lastNonDefinition);
-		return { "definition, footnoteDefinition"(node) {
+		const options = parseOptions$4(context.options[0]);
+		/**
+		* Determine whether a node can be placed as the last node of the document or a section.
+		*/
+		function canBePlacedLastNode(node) {
+			return node.type === "definition" || node.type === "footnoteDefinition" || node.type === "html" && (node.value.startsWith("<!--") || node.value.startsWith("<script") || node.value.startsWith("<style"));
+		}
+		const beforeLastNode = sourceCode.ast.children.findLast((node) => !canBePlacedLastNode(node));
+		if (!beforeLastNode) return {};
+		let lastSection = {
+			heading: null,
+			linkReferenceIds: /* @__PURE__ */ new Set(),
+			footnoteReferenceIds: /* @__PURE__ */ new Set(),
+			nextHeading: null
+		};
+		const sections = [lastSection];
+		const definitions = [];
+		/**
+		* Get the expected placement of a definition or footnote definition node.
+		*/
+		function getExpectedPlacement(node) {
+			let referencedFromSingleSection;
+			let referencedFromMultipleSections;
+			let referenceIdsNs;
+			if (node.type === "definition") {
+				({referencedFromSingleSection, referencedFromMultipleSections} = options.linkDefinitionPlacement);
+				referenceIdsNs = "linkReferenceIds";
+			} else if (node.type === "footnoteDefinition") {
+				({referencedFromSingleSection, referencedFromMultipleSections} = options.footnoteDefinitionPlacement);
+				referenceIdsNs = "footnoteReferenceIds";
+			} else return { type: "document-last" };
+			if (referencedFromSingleSection === "document-last" && referencedFromSingleSection === referencedFromMultipleSections) return { type: "document-last" };
+			const referencedSections = [];
+			for (const section of sections) {
+				if (!section[referenceIdsNs].has(node.identifier)) continue;
+				referencedSections.push(section);
+				if (referencedSections.length > 1 && referencedFromMultipleSections !== "last-reference-section-last") return {
+					type: referencedFromMultipleSections,
+					section: referencedSections[0]
+				};
+			}
+			if (referencedSections.length === 0) return { type: "document-last" };
+			if (referencedSections.length === 1) return {
+				type: referencedFromSingleSection,
+				section: referencedSections[0]
+			};
+			return {
+				type: referencedFromMultipleSections,
+				section: referencedSections[referencedSections.length - 1]
+			};
+		}
+		/**
+		* Verify the position of a definition or footnote definition node.
+		*/
+		function verifyDefinitionPosition(node) {
+			const expectedPlacement = getExpectedPlacement(node);
+			if (expectedPlacement.type === "document-last") verifyDefinitionOnDocumentLast(node, "definitionsDocumentLast");
+			else if (expectedPlacement.type === "section-last" || expectedPlacement.type === "first-reference-section-last" || expectedPlacement.type === "last-reference-section-last") if (!expectedPlacement.section.nextHeading) verifyDefinitionOnDocumentLast(node, "definitionsLastSectionLast");
+			else verifyDefinitionOnSectionLast(node, expectedPlacement.section.nextHeading);
+		}
+		/**
+		* Verify that a definition or footnote definition node is at the end of the document.
+		*/
+		function verifyDefinitionOnDocumentLast(node, messageId) {
+			if (!beforeLastNode) return;
 			const range = sourceCode.getRange(node);
-			if (lastNonDefinitionRange[1] <= range[0]) return;
+			if (sourceCode.getRange(beforeLastNode)[1] <= range[0]) return;
 			context.report({
 				node,
-				message: "Definition or footnote definition should be placed at the end of the document.",
-				*fix(fixer) {
-					let rangeStart = range[0];
-					for (let index = range[0] - 1; index >= 0; index--) {
-						if (sourceCode.text[index].trim()) break;
-						rangeStart = index;
-					}
-					yield fixer.removeRange([rangeStart, range[1]]);
-					yield fixer.insertTextAfterRange(lastNonDefinitionRange, sourceCode.text.slice(rangeStart, range[1]));
+				messageId,
+				fix(fixer) {
+					return fixToMoveFromBeforeLastOfSectionToLastOfSection(fixer, beforeLastNode, node);
 				}
 			});
-		} };
+		}
+		/**
+		* Verify that a definition or footnote definition node is at the end of its section.
+		*/
+		function verifyDefinitionOnSectionLast(node, nextSectionHeading) {
+			const beforeLastOfSectionNode = getSectionBeforeLastNode(nextSectionHeading);
+			if (!beforeLastOfSectionNode) return;
+			const range = sourceCode.getRange(node);
+			const beforeLastOfSectionRange = sourceCode.getRange(beforeLastOfSectionNode);
+			const nextSectionHeadingRange = sourceCode.getRange(nextSectionHeading);
+			if (beforeLastOfSectionRange[1] <= range[0] && range[1] <= nextSectionHeadingRange[0]) return;
+			const expectedStartLine = sourceCode.getLoc(beforeLastOfSectionNode).end.line + 1;
+			const expectedEndLine = sourceCode.getLoc(nextSectionHeading).start.line - 1;
+			context.report({
+				node,
+				messageId: "definitionsSectionLast",
+				data: { at: expectedStartLine === expectedEndLine ? `L${expectedStartLine}` : `between L${expectedStartLine} and L${expectedEndLine}` },
+				fix(fixer) {
+					if (range[0] < beforeLastOfSectionRange[1]) return fixToMoveFromBeforeLastOfSectionToLastOfSection(fixer, beforeLastOfSectionNode, node);
+					return fixToMoveFromAfterLastOfSectionToLastOfSection(fixer, nextSectionHeading, node);
+				}
+			});
+		}
+		/**
+		* Get the node before the last node of a section.
+		*/
+		function getSectionBeforeLastNode(nextSectionHeading) {
+			let candidate = getPrevSibling(sourceCode, nextSectionHeading);
+			while (candidate && canBePlacedLastNode(candidate)) candidate = getPrevSibling(sourceCode, candidate);
+			return candidate;
+		}
+		/**
+		* Fixer to move a definition or footnote definition node from before the last of the document/section
+		* to the last of the document/section.
+		*/
+		function fixToMoveFromBeforeLastOfSectionToLastOfSection(fixer, prev, node) {
+			const next = getNextSibling(sourceCode, prev);
+			return fixToMove(fixer, prev, next, node);
+		}
+		/**
+		* Fixer to move a definition or footnote definition node from after the last of the document/section
+		* to the last of the document/section.
+		*/
+		function fixToMoveFromAfterLastOfSectionToLastOfSection(fixer, next, node) {
+			const prev = getPrevSibling(sourceCode, next);
+			if (!prev) return null;
+			return fixToMove(fixer, prev, next, node);
+		}
+		/**
+		* Fixer to move a definition or footnote definition node to after the prev node.
+		*/
+		function* fixToMove(fixer, prev, next, node) {
+			const range = sourceCode.getRange(node);
+			const loc = sourceCode.getLoc(node);
+			const lineStart = range[0] - loc.start.column + 1;
+			let rangeStart = lineStart;
+			let lineFeeds = 0;
+			for (let index = rangeStart - 1; index >= 0; index--) {
+				const c = sourceCode.text[index];
+				if (c.trim()) break;
+				rangeStart = index;
+				if (c === "\n") lineFeeds++;
+			}
+			yield fixer.removeRange([rangeStart, range[1]]);
+			const startColumnOffset = loc.start.column - 1;
+			const insertLines = sourceCode.lines.slice(loc.start.line - 1, loc.end.line).map((lineText, i, arr) => {
+				if (i === arr.length - 1) return lineText.slice(startColumnOffset, loc.end.column - 1);
+				return lineText.slice(startColumnOffset);
+			});
+			let insertText = sourceCode.text.slice(rangeStart, lineStart) + insertLines.join(/\r?\n/u.exec(sourceCode.text)?.[0] ?? "\n");
+			if (prev.type === "footnoteDefinition" && node.type !== "footnoteDefinition" && lineFeeds <= 1) insertText = `\n${insertText}`;
+			if (next && node.type === "footnoteDefinition" && next.type !== "footnoteDefinition") {
+				const prevLoc = sourceCode.getLoc(prev);
+				const nextLoc = sourceCode.getLoc(next);
+				if (!(prevLoc.end.line + 1 < nextLoc.start.line)) insertText = `${insertText}\n`;
+			}
+			yield fixer.insertTextAfter(prev, insertText);
+		}
+		const containerStack = [];
+		return {
+			"blockquote, listItem, footnoteDefinition"(node) {
+				containerStack.push(node);
+			},
+			"blockquote, listItem, footnoteDefinition:exit"() {
+				containerStack.pop();
+			},
+			heading(node) {
+				if (containerStack.length > 0) return;
+				lastSection.nextHeading = node;
+				lastSection = {
+					heading: node,
+					linkReferenceIds: /* @__PURE__ */ new Set(),
+					footnoteReferenceIds: /* @__PURE__ */ new Set(),
+					nextHeading: null
+				};
+				sections.push(lastSection);
+			},
+			linkReference(node) {
+				lastSection.linkReferenceIds.add(node.identifier);
+			},
+			imageReference(node) {
+				lastSection.linkReferenceIds.add(node.identifier);
+			},
+			footnoteReference(node) {
+				lastSection.footnoteReferenceIds.add(node.identifier);
+			},
+			"definition, footnoteDefinition"(node) {
+				definitions.push(node);
+			},
+			"root:exit"() {
+				for (const node of definitions) verifyDefinitionPosition(node);
+			}
+		};
 	}
 });
 
@@ -6233,11 +6482,11 @@ var link_bracket_newline_default = createRule("link-bracket-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$5(context.options[0]);
+		const optionProvider = parseOptions$6(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$5(option) {
+		function parseOptions$6(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (bracketsRange) => {
@@ -6711,11 +6960,11 @@ var link_paren_newline_default = createRule("link-paren-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$5(context.options[0]);
+		const optionProvider = parseOptions$6(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$5(option) {
+		function parseOptions$6(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (openingParenIndex, closingParenIndex) => {
@@ -10022,26 +10271,121 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 	create(context) {
 		const sourceCode = context.sourceCode;
 		const columnOption = (context.options[0] || {}).column || "minimum";
+		class TableContext {
+			rows;
+			columnCount;
+			_cacheHasSpaceBetweenContentAndTrailingPipe = /* @__PURE__ */ new Map();
+			_cacheExpectedPipePosition = /* @__PURE__ */ new Map();
+			constructor(parsed) {
+				const rows = [parsedTableRowToRowData(parsed.headerRow), parsedTableDelimiterRowToRowData(parsed.delimiterRow)];
+				for (const bodyRow of parsed.bodyRows) rows.push(parsedTableRowToRowData(bodyRow));
+				this.rows = rows;
+				let columnCount = 0;
+				for (const row of rows) columnCount = Math.max(columnCount, row.cells.length);
+				this.columnCount = columnCount;
+			}
+			/**
+			* Get the expected pipe position for the index
+			*/
+			getExpectedPipePosition(pipeIndex) {
+				let v = this._cacheExpectedPipePosition.get(pipeIndex);
+				if (v !== void 0) return v;
+				v = this._computeExpectedPipePositionWithoutCache(pipeIndex);
+				this._cacheExpectedPipePosition.set(pipeIndex, v);
+				return v;
+			}
+			/**
+			* Check if there is at least one space between content and trailing pipe
+			* for the index
+			*
+			* This is used to determine if the pipe should be aligned with a space before it.
+			*/
+			hasSpaceBetweenContentAndTrailingPipe(pipeIndex) {
+				if (pipeIndex === 0) return false;
+				let v = this._cacheHasSpaceBetweenContentAndTrailingPipe.get(pipeIndex);
+				if (v != null) return v;
+				v = this._hasSpaceBetweenContentAndTrailingPipeWithoutCache(pipeIndex);
+				this._cacheHasSpaceBetweenContentAndTrailingPipe.set(pipeIndex, v);
+				return v;
+			}
+			/**
+			* Get the expected pipe position for the index
+			*/
+			_computeExpectedPipePositionWithoutCache(pipeIndex) {
+				if (pipeIndex === 0) {
+					const firstCell = this.rows[0].cells[0];
+					const firstToken = firstCell.leadingPipe ?? firstCell.content;
+					if (!firstToken) return null;
+					return getTextWidth(sourceCode.lines[firstToken.loc.start.line - 1].slice(0, firstToken.loc.start.column - 1));
+				}
+				if (columnOption === "minimum") return this.getMinimumPipePosition(pipeIndex);
+				else if (columnOption === "consistent") {
+					const columnIndex = pipeIndex - 1;
+					for (const row of this.rows) {
+						if (row.cells.length <= columnIndex) continue;
+						const cell = row.cells[columnIndex];
+						if (cell.type === "delimiter" || !cell.trailingPipe) continue;
+						const width = getTextWidth(sourceCode.lines[cell.trailingPipe.loc.start.line - 1].slice(0, cell.trailingPipe.loc.start.column - 1));
+						return Math.max(width, this.getMinimumPipePosition(pipeIndex) || 0);
+					}
+				}
+				return null;
+			}
+			/**
+			* Get the minimum pipe position for the index
+			*/
+			getMinimumPipePosition(pipeIndex) {
+				const needSpaceBeforePipe = this.hasSpaceBetweenContentAndTrailingPipe(pipeIndex);
+				let maxWidth = 0;
+				const columnIndex = pipeIndex - 1;
+				for (const row of this.rows) {
+					if (row.cells.length <= columnIndex) continue;
+					const cell = row.cells[columnIndex];
+					let width;
+					if (cell.type === "delimiter") {
+						const minimumDelimiterLength = getMinimumDelimiterLength(cell.align);
+						width = getTextWidth(sourceCode.lines[cell.delimiter.loc.start.line - 1].slice(0, cell.delimiter.loc.start.column - 1)) + minimumDelimiterLength;
+					} else {
+						if (!cell.content) continue;
+						width = getTextWidth(sourceCode.lines[cell.content.loc.end.line - 1].slice(0, cell.content.loc.end.column - 1));
+					}
+					if (needSpaceBeforePipe) width += 1;
+					maxWidth = Math.max(maxWidth, width);
+				}
+				return maxWidth;
+			}
+			/**
+			* Check if there is at least one space between content and trailing pipe
+			*/
+			_hasSpaceBetweenContentAndTrailingPipeWithoutCache(pipeIndex) {
+				const columnIndex = pipeIndex - 1;
+				for (const row of this.rows) {
+					if (row.cells.length <= columnIndex) continue;
+					const cell = row.cells[columnIndex];
+					if (!cell.trailingPipe) continue;
+					let content;
+					if (cell.type === "delimiter") content = cell.delimiter;
+					else {
+						if (!cell.content) continue;
+						content = cell.content;
+					}
+					if (content.range[1] < cell.trailingPipe.range[0]) continue;
+					return false;
+				}
+				return true;
+			}
+		}
 		/**
 		* Verify the table pipes
 		*/
-		function verifyTablePipes(rows) {
-			let columnCount = 0;
-			for (const row of rows) columnCount = Math.max(columnCount, row.cells.length);
-			let targetRows = [...rows];
-			for (let pipeIndex = 0; pipeIndex <= columnCount; pipeIndex++) {
-				const expected = getExpectedPipePosition(rows, pipeIndex);
-				if (expected == null) continue;
-				const unreportedRows = [];
-				for (const row of targetRows) if (verifyRowPipe(row, pipeIndex, expected)) unreportedRows.push(row);
-				targetRows = unreportedRows;
-				if (targetRows.length === 0) break;
-			}
+		function verifyTablePipes(table) {
+			const targetRows = [...table.rows];
+			for (const row of targetRows) for (let pipeIndex = 0; pipeIndex <= table.columnCount; pipeIndex++) if (!verifyRowPipe(row, pipeIndex, table)) break;
 		}
 		/**
 		* Verify the pipe in the row
 		*/
-		function verifyRowPipe(row, pipeIndex, expected) {
+		function verifyRowPipe(row, pipeIndex, table) {
 			let cellIndex;
 			let pipe;
 			if (pipeIndex === 0) {
@@ -10055,15 +10399,14 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 			const cell = row.cells[cellIndex];
 			const pipeToken = cell[pipe];
 			if (!pipeToken) return true;
-			return verifyPipe(pipeToken, expected, {
-				cell,
-				pipeIndex
-			});
+			return verifyPipe(pipeToken, pipeIndex, table, cell);
 		}
 		/**
 		* Verify the pipe position
 		*/
-		function verifyPipe(pipe, expected, ctx) {
+		function verifyPipe(pipe, pipeIndex, table, cell) {
+			const expected = table.getExpectedPipePosition(pipeIndex);
+			if (expected == null) return true;
 			const actual = getTextWidth(sourceCode.lines[pipe.loc.start.line - 1].slice(0, pipe.loc.start.column - 1));
 			const diff = expected - actual;
 			if (diff === 0) return true;
@@ -10077,22 +10420,22 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 				},
 				fix(fixer) {
 					if (diff > 0) {
-						if (ctx.pipeIndex === 0 || ctx.cell.type === "cell") return fixer.insertTextBeforeRange(pipe.range, " ".repeat(diff));
-						return fixer.insertTextAfterRange([ctx.cell.delimiter.range[0], ctx.cell.delimiter.range[0] + 1], "-".repeat(diff));
+						if (pipeIndex === 0 || cell.type === "cell") return fixer.insertTextBeforeRange(pipe.range, " ".repeat(diff));
+						return fixer.insertTextAfterRange([cell.delimiter.range[0], cell.delimiter.range[0] + 1], "-".repeat(diff));
 					}
 					const baseEdit = fixRemoveSpaces();
 					if (baseEdit) return baseEdit;
-					if (ctx.pipeIndex === 0 || ctx.cell.type === "cell") return null;
-					const beforeDelimiter = sourceCode.lines[ctx.cell.delimiter.loc.start.line - 1].slice(0, ctx.cell.delimiter.loc.start.column - 1);
+					if (pipeIndex === 0 || cell.type === "cell") return null;
+					const beforeDelimiter = sourceCode.lines[cell.delimiter.loc.start.line - 1].slice(0, cell.delimiter.loc.start.column - 1);
 					const widthBeforeDelimiter = getTextWidth(beforeDelimiter);
 					const newLength = expected - widthBeforeDelimiter;
-					const minimumDelimiterLength = getMinimumDelimiterLength(ctx.cell.align);
-					const spaceAfter = isNeedSpaceAfterContent(ctx.cell) ? " " : "";
+					const minimumDelimiterLength = getMinimumDelimiterLength(cell.align);
+					const spaceAfter = table.hasSpaceBetweenContentAndTrailingPipe(pipeIndex) ? " " : "";
 					if (newLength < minimumDelimiterLength + spaceAfter.length) return null;
-					const delimiterPrefix = ctx.cell.align === "left" || ctx.cell.align === "center" ? ":" : "";
-					const delimiterSuffix = (ctx.cell.align === "right" || ctx.cell.align === "center" ? ":" : "") + spaceAfter;
+					const delimiterPrefix = cell.align === "left" || cell.align === "center" ? ":" : "";
+					const delimiterSuffix = (cell.align === "right" || cell.align === "center" ? ":" : "") + spaceAfter;
 					const newDelimiter = "-".repeat(newLength - delimiterPrefix.length - delimiterSuffix.length);
-					return fixer.replaceTextRange([ctx.cell.delimiter.range[0], pipe.range[0]], delimiterPrefix + newDelimiter + delimiterSuffix);
+					return fixer.replaceTextRange([cell.delimiter.range[0], pipe.range[0]], delimiterPrefix + newDelimiter + delimiterSuffix);
 					/**
 					* Fixer to remove spaces before the pipe
 					*/
@@ -10102,7 +10445,7 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 						const spacesBeforePipeLength = beforePipe.length - trimmedBeforePipe.length;
 						const widthBeforePipe = getTextWidth(trimmedBeforePipe);
 						const newSpacesLength = expected - widthBeforePipe;
-						if (newSpacesLength < (ctx.pipeIndex > 0 && isNeedSpaceAfterContent(ctx.cell) ? 1 : 0)) return null;
+						if (newSpacesLength < (table.hasSpaceBetweenContentAndTrailingPipe(pipeIndex) ? 1 : 0)) return null;
 						return fixer.replaceTextRange([pipe.range[0] - spacesBeforePipeLength, pipe.range[0]], " ".repeat(newSpacesLength));
 					}
 				}
@@ -10110,106 +10453,47 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 			return false;
 		}
 		/**
-		* Get the expected pipe position for the index
-		*/
-		function getExpectedPipePosition(rows, pipeIndex) {
-			if (pipeIndex === 0) {
-				const firstCell = rows[0].cells[0];
-				const firstToken = firstCell.leadingPipe ?? firstCell.content;
-				if (!firstToken) return null;
-				return getTextWidth(sourceCode.lines[firstToken.loc.start.line - 1].slice(0, firstToken.loc.start.column - 1));
-			}
-			if (columnOption === "minimum") return getMinimumPipePosition(rows, pipeIndex);
-			else if (columnOption === "consistent") {
-				const columnIndex = pipeIndex - 1;
-				for (const row of rows) {
-					if (row.cells.length <= columnIndex) continue;
-					const cell = row.cells[columnIndex];
-					if (cell.type === "delimiter" || !cell.trailingPipe) continue;
-					const width = getTextWidth(sourceCode.lines[cell.trailingPipe.loc.start.line - 1].slice(0, cell.trailingPipe.loc.start.column - 1));
-					return Math.max(width, getMinimumPipePosition(rows, pipeIndex) || 0);
-				}
-			}
-			return null;
-		}
-		/**
-		* Get the minimum pipe position for the index
-		*/
-		function getMinimumPipePosition(rows, pipeIndex) {
-			let maxWidth = 0;
-			const columnIndex = pipeIndex - 1;
-			for (const row of rows) {
-				if (row.cells.length <= columnIndex) continue;
-				const cell = row.cells[columnIndex];
-				let width;
-				if (cell.type === "delimiter") {
-					const minimumDelimiterLength = getMinimumDelimiterLength(cell.align);
-					width = getTextWidth(sourceCode.lines[cell.delimiter.loc.start.line - 1].slice(0, cell.delimiter.loc.start.column - 1)) + minimumDelimiterLength;
-				} else {
-					if (!cell.content) continue;
-					width = getTextWidth(sourceCode.lines[cell.content.loc.end.line - 1].slice(0, cell.content.loc.end.column - 1));
-				}
-				if (isNeedSpaceAfterContent(cell)) width += 1;
-				maxWidth = Math.max(maxWidth, width);
-			}
-			return maxWidth;
-		}
-		/**
 		* Get the minimum delimiter length based on alignment
 		*/
 		function getMinimumDelimiterLength(align) {
 			return align === "none" ? 1 : align === "center" ? 3 : 2;
 		}
-		/**
-		* Check if a cell needs a space after its content
-		*/
-		function isNeedSpaceAfterContent(cell) {
-			let content;
-			if (cell.type === "delimiter") content = cell.delimiter;
-			else {
-				if (!cell.content) return false;
-				content = cell.content;
-			}
-			return cell.trailingPipe && content.range[1] < cell.trailingPipe.range[0];
-		}
-		/**
-		* Convert a parsed table row to row data
-		*/
-		function parsedTableRowToRowData(parsedRow) {
-			return { cells: parsedRow.cells.map((cell, index) => {
-				const nextCell = index + 1 < parsedRow.cells.length ? parsedRow.cells[index + 1] : null;
-				return {
-					type: "cell",
-					leadingPipe: cell.leadingPipe,
-					content: cell.cell,
-					trailingPipe: nextCell ? nextCell.leadingPipe : parsedRow.trailingPipe
-				};
-			}) };
-		}
-		/**
-		* Convert a parsed table delimiter row to row data
-		*/
-		function parsedTableDelimiterRowToRowData(parsedDelimiterRow) {
-			return { cells: parsedDelimiterRow.delimiters.map((cell, index) => {
-				const nextCell = index + 1 < parsedDelimiterRow.delimiters.length ? parsedDelimiterRow.delimiters[index + 1] : null;
-				return {
-					type: "delimiter",
-					leadingPipe: cell.leadingPipe,
-					delimiter: cell.delimiter,
-					align: cell.delimiter.align,
-					trailingPipe: nextCell ? nextCell.leadingPipe : parsedDelimiterRow.trailingPipe
-				};
-			}) };
-		}
 		return { table(node) {
 			const parsed = parseTable(sourceCode, node);
 			if (!parsed) return;
-			const rows = [parsedTableRowToRowData(parsed.headerRow), parsedTableDelimiterRowToRowData(parsed.delimiterRow)];
-			for (const bodyRow of parsed.bodyRows) rows.push(parsedTableRowToRowData(bodyRow));
-			verifyTablePipes(rows);
+			verifyTablePipes(new TableContext(parsed));
 		} };
 	}
 });
+/**
+* Convert a parsed table row to row data
+*/
+function parsedTableRowToRowData(parsedRow) {
+	return { cells: parsedRow.cells.map((cell, index) => {
+		const nextCell = index + 1 < parsedRow.cells.length ? parsedRow.cells[index + 1] : null;
+		return {
+			type: "cell",
+			leadingPipe: cell.leadingPipe,
+			content: cell.cell,
+			trailingPipe: nextCell ? nextCell.leadingPipe : parsedRow.trailingPipe
+		};
+	}) };
+}
+/**
+* Convert a parsed table delimiter row to row data
+*/
+function parsedTableDelimiterRowToRowData(parsedDelimiterRow) {
+	return { cells: parsedDelimiterRow.delimiters.map((cell, index) => {
+		const nextCell = index + 1 < parsedDelimiterRow.delimiters.length ? parsedDelimiterRow.delimiters[index + 1] : null;
+		return {
+			type: "delimiter",
+			leadingPipe: cell.leadingPipe,
+			delimiter: cell.delimiter,
+			align: cell.delimiter.align,
+			trailingPipe: nextCell ? nextCell.leadingPipe : parsedDelimiterRow.trailingPipe
+		};
+	}) };
+}
 
 //#endregion
 //#region src/rules/table-pipe-spacing.ts
@@ -10844,7 +11128,7 @@ const rules$1 = [
 
 //#endregion
 //#region src/configs/recommended.ts
-var recommended_exports = __export({
+var recommended_exports = /* @__PURE__ */ __export({
 	files: () => files$1,
 	language: () => language$1,
 	languageOptions: () => languageOptions$1,
@@ -10874,7 +11158,7 @@ const rules$3 = {
 
 //#endregion
 //#region src/configs/standard.ts
-var standard_exports = __export({
+var standard_exports = /* @__PURE__ */ __export({
 	files: () => files,
 	language: () => language,
 	languageOptions: () => languageOptions,
@@ -10935,12 +11219,12 @@ const rules$2 = {
 
 //#endregion
 //#region src/meta.ts
-var meta_exports = __export({
+var meta_exports = /* @__PURE__ */ __export({
 	name: () => name,
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.25.0";
+const version = "0.26.1";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {