eslint-plugin-markdown-preferences 0.24.0 → 0.25.0

package/lib/index.js

@@ -109,13 +109,20 @@ function getThematicBreakMarker(sourceCode, node) {
 * Get the source location from a range in a node.
 */
 function getSourceLocationFromRange(sourceCode, node, range) {
-	const [nodeStart] = sourceCode.getRange(node);
+	const nodeRange = sourceCode.getRange(node);
+	const loc = sourceCode.getLoc(node);
+	if (nodeRange[1] <= range[0]) return getSourceLocationFromRangeAndSourcePosition(sourceCode, nodeRange[1], loc.end, range);
+	return getSourceLocationFromRangeAndSourcePosition(sourceCode, nodeRange[0], loc.start, range);
+}
+/**
+* Get the source location from a range
+*/
+function getSourceLocationFromRangeAndSourcePosition(sourceCode, startIndex, startLoc, range) {
 	let startLine, startColumn;
-	if (nodeStart <= range[0]) {
-		const loc = sourceCode.getLoc(node);
-		const beforeLines = sourceCode.text.slice(nodeStart, range[0]).split(/\n/u);
-		startLine = loc.start.line + beforeLines.length - 1;
-		startColumn = (beforeLines.length === 1 ? loc.start.column : 1) + (beforeLines.at(-1) || "").length;
+	if (startIndex <= range[0]) {
+		const beforeLines = sourceCode.text.slice(startIndex, range[0]).split(/\n/u);
+		startLine = startLoc.line + beforeLines.length - 1;
+		startColumn = (beforeLines.length === 1 ? startLoc.column : 1) + (beforeLines.at(-1) || "").length;
 	} else {
 		const beforeLines = sourceCode.text.slice(0, range[0]).split(/\n/u);
 		startLine = beforeLines.length;
@@ -364,15 +371,23 @@ function getParsedLines(sourceCode) {
 }
 
 //#endregion
-//#region src/utils/get-text-width.ts
+//#region src/utils/text-width.ts
 let segmenter;
 /**
 * Get the width of a text string.
 */
-function getTextWidth(text) {
-	if (!text.includes("	")) return stringWidth(text);
+function getTextWidth(text, start = 0, end = text.length) {
+	if (!text.includes("	")) return stringWidth(text.slice(start, end));
 	if (!segmenter) segmenter = new Intl.Segmenter("en");
-	let width = 0;
+	const prefixWidth = getTextWidthBySegment(text.slice(0, start), 0);
+	return getTextWidthBySegment(text.slice(start, end), prefixWidth);
+}
+/**
+* Get the width of a text string by segmenter.
+*/
+function getTextWidthBySegment(text, startWidth) {
+	if (!segmenter) segmenter = new Intl.Segmenter("en");
+	let width = startWidth;
 	for (const { segment: c } of segmenter.segment(text)) if (c === "	") width += 4 - width % 4;
 	else width += stringWidth(c);
 	return width;
@@ -386,7 +401,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 		docs: {
 			description: "enforce consistent length for the closing sequence (trailing #s) in ATX headings.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -524,7 +539,7 @@ var atx_heading_closing_sequence_default = createRule("atx-heading-closing-seque
 		docs: {
 			description: "enforce consistent use of closing sequence in ATX headings.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -700,7 +715,7 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 		docs: {
 			description: "enforce consistent alignment of blockquote markers",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -783,7 +798,7 @@ function getOtherMarker(unavailableMarker) {
 /**
 * Parse rule options.
 */
-function parseOptions$3(options) {
+function parseOptions$4(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}").`);
@@ -815,7 +830,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 		docs: {
 			description: "enforce consistent bullet list (unordered list) marker style",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -851,7 +866,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$3(context.options[0] || {});
+		const options = parseOptions$4(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -1114,7 +1129,7 @@ var code_fence_length_default = createRule("code-fence-length", {
 		docs: {
 			description: "enforce consistent code fence length in fenced code blocks.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -1251,7 +1266,7 @@ var code_fence_style_default = createRule("code-fence-style", {
 		docs: {
 			description: "enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -1298,7 +1313,7 @@ var definitions_last_default = createRule("definitions-last", {
 		docs: {
 			description: "require link definitions and footnote definitions to be placed at the end of the document",
 			categories: [],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -3422,7 +3437,7 @@ var emphasis_delimiters_style_default = createRule("emphasis-delimiters-style",
 		docs: {
 			description: "enforce a consistent delimiter style for emphasis and strong emphasis",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -3604,7 +3619,7 @@ var hard_linebreak_style_default = createRule("hard-linebreak-style", {
 		docs: {
 			description: "enforce consistent hard linebreak style.",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -5037,7 +5052,7 @@ function parseListItem(sourceCode, node) {
 /**
 * Parse options.
 */
-function parseOptions$2(options) {
+function parseOptions$3(options) {
 	const listItems = options?.listItems;
 	return { listItems: {
 		first: listItems?.first ?? 1,
@@ -5051,7 +5066,7 @@ var indent_default = createRule("indent", {
 		docs: {
 			description: "enforce consistent indentation in Markdown files",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -5090,7 +5105,7 @@ var indent_default = createRule("indent", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$2(context.options[0]);
+		const options = parseOptions$3(context.options[0]);
 		class AbsBlockStack {
 			violations = [];
 			getCurrentBlockquote() {
@@ -6039,7 +6054,7 @@ var level1_heading_style_default = createRule("level1-heading-style", {
 		docs: {
 			description: "enforce consistent style for level 1 headings",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -6116,7 +6131,7 @@ var level2_heading_style_default = createRule("level2-heading-style", {
 		docs: {
 			description: "enforce consistent style for level 2 headings",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -6193,7 +6208,7 @@ var link_bracket_newline_default = createRule("link-bracket-newline", {
 		docs: {
 			description: "enforce linebreaks after opening and before closing link brackets",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6218,11 +6233,11 @@ var link_bracket_newline_default = createRule("link-bracket-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$4(context.options[0]);
+		const optionProvider = parseOptions$5(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$4(option) {
+		function parseOptions$5(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (bracketsRange) => {
@@ -6353,7 +6368,7 @@ var link_bracket_newline_default = createRule("link-bracket-newline", {
 /**
 * The basic option for links and images.
 */
-function parseOptions$1(option) {
+function parseOptions$2(option) {
 	const space = option?.space ?? "never";
 	const imagesInLinks = option?.imagesInLinks;
 	return {
@@ -6382,7 +6397,7 @@ var link_bracket_spacing_default = createRule("link-bracket-spacing", {
 		docs: {
 			description: "enforce consistent spacing inside link brackets",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6403,7 +6418,7 @@ var link_bracket_spacing_default = createRule("link-bracket-spacing", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$1(context.options[0]);
+		const options = parseOptions$2(context.options[0]);
 		/**
 		* Verify the space after the opening bracket and before the closing bracket.
 		*/
@@ -6546,7 +6561,7 @@ var link_destination_style_default = createRule("link-destination-style", {
 		docs: {
 			description: "enforce a consistent style for link destinations",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -6671,7 +6686,7 @@ var link_paren_newline_default = createRule("link-paren-newline", {
 		docs: {
 			description: "enforce linebreaks after opening and before closing link parentheses",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6696,11 +6711,11 @@ var link_paren_newline_default = createRule("link-paren-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$4(context.options[0]);
+		const optionProvider = parseOptions$5(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$4(option) {
+		function parseOptions$5(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (openingParenIndex, closingParenIndex) => {
@@ -6815,7 +6830,7 @@ var link_paren_spacing_default = createRule("link-paren-spacing", {
 		docs: {
 			description: "enforce consistent spacing inside link parentheses",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6950,7 +6965,7 @@ var link_title_style_default = createRule("link-title-style", {
 		docs: {
 			description: "enforce a consistent style for link titles",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -7032,7 +7047,7 @@ var list_marker_alignment_default = createRule("list-marker-alignment", {
 		docs: {
 			description: "enforce consistent alignment of list markers",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -7131,7 +7146,7 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 		docs: {
 			description: "disallow laziness in blockquotes",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: void 0,
 		hasSuggestions: true,
@@ -7230,6 +7245,193 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 	}
 });
 
+//#endregion
+//#region src/utils/table.ts
+/**
+* Parse the table.
+*/
+function parseTable(sourceCode, node) {
+	const headerRow = parseTableRow(sourceCode, node.children[0]);
+	if (!headerRow) return null;
+	const delimiterRow = parseTableDelimiterRow(sourceCode, node);
+	if (!delimiterRow) return null;
+	const bodyRows = [];
+	for (const child of node.children.slice(1)) {
+		const bodyRow = parseTableRow(sourceCode, child);
+		if (!bodyRow) return null;
+		bodyRows.push(bodyRow);
+	}
+	return {
+		headerRow,
+		delimiterRow,
+		bodyRows
+	};
+}
+/**
+* Parse the table delimiter row.
+*/
+function parseTableDelimiterRow(sourceCode, node) {
+	const headerRow = node.children[0];
+	const headerRange = sourceCode.getRange(headerRow);
+	const delimiterEndIndex = node.children.length > 1 ? sourceCode.getRange(node.children[1])[0] : sourceCode.getRange(node)[1];
+	const delimiterText = sourceCode.text.slice(headerRange[1], delimiterEndIndex);
+	const parsed = parseTableDelimiterRowFromText(delimiterText);
+	if (!parsed) return null;
+	const delimiters = parsed.delimiters.map((d) => {
+		let leadingPipe = null;
+		if (d.leadingPipe) {
+			const leadingPipeRange = [headerRange[1] + d.leadingPipe.range[0], headerRange[1] + d.leadingPipe.range[1]];
+			leadingPipe = {
+				text: d.leadingPipe.text,
+				range: leadingPipeRange,
+				loc: getSourceLocationFromRange(sourceCode, headerRow, leadingPipeRange)
+			};
+		}
+		const delimiterRange = [headerRange[1] + d.delimiter.range[0], headerRange[1] + d.delimiter.range[1]];
+		return {
+			leadingPipe,
+			delimiter: {
+				text: d.delimiter.text,
+				align: d.delimiter.text.startsWith(":") ? d.delimiter.text.endsWith(":") ? "center" : "left" : d.delimiter.text.endsWith(":") ? "right" : "none",
+				range: delimiterRange,
+				loc: getSourceLocationFromRange(sourceCode, headerRow, delimiterRange)
+			}
+		};
+	});
+	let trailingPipe = null;
+	if (parsed.trailingPipe) {
+		const trailingPipeRange = [headerRange[1] + parsed.trailingPipe.range[0], headerRange[1] + parsed.trailingPipe.range[1]];
+		trailingPipe = {
+			text: parsed.trailingPipe.text,
+			range: trailingPipeRange,
+			loc: getSourceLocationFromRange(sourceCode, headerRow, trailingPipeRange)
+		};
+	}
+	const firstToken = delimiters[0].leadingPipe ?? delimiters[0].delimiter;
+	const lastToken = trailingPipe ?? delimiters[delimiters.length - 1].delimiter;
+	return {
+		delimiters,
+		trailingPipe,
+		range: [firstToken.range[0], lastToken.range[1]],
+		loc: {
+			start: firstToken.loc.start,
+			end: lastToken.loc.end
+		}
+	};
+}
+/**
+* Parse the table row.
+*/
+function parseTableRow(sourceCode, node) {
+	const cells = [];
+	let trailingPipe = null;
+	for (const cell of node.children) {
+		const cellRange = sourceCode.getRange(cell);
+		const cellLoc = sourceCode.getLoc(cell);
+		const leadingPipe = sourceCode.text[cellRange[0]] === "|" ? {
+			text: "|",
+			range: [cellRange[0], cellRange[0] + 1],
+			loc: {
+				start: cellLoc.start,
+				end: {
+					line: cellLoc.start.line,
+					column: cellLoc.start.column + 1
+				}
+			}
+		} : null;
+		if (trailingPipe && leadingPipe) return null;
+		let parsedCell = null;
+		if (cell.children.length > 0) {
+			const firstChild = cell.children[0];
+			const lastChild = cell.children[cell.children.length - 1];
+			parsedCell = {
+				range: [sourceCode.getRange(firstChild)[0], sourceCode.getRange(lastChild)[1]],
+				loc: {
+					start: sourceCode.getLoc(firstChild).start,
+					end: sourceCode.getLoc(lastChild).end
+				}
+			};
+		}
+		cells.push({
+			leadingPipe,
+			cell: parsedCell
+		});
+		trailingPipe = sourceCode.text[cellRange[1] - 1] === "|" ? {
+			text: "|",
+			range: [cellRange[1] - 1, cellRange[1]],
+			loc: {
+				start: {
+					line: cellLoc.end.line,
+					column: cellLoc.end.column - 1
+				},
+				end: cellLoc.end
+			}
+		} : null;
+	}
+	const firstToken = cells[0].leadingPipe ?? cells[0].cell;
+	const lastToken = trailingPipe ?? cells[cells.length - 1].cell ?? cells[cells.length - 1].leadingPipe;
+	return {
+		cells,
+		trailingPipe,
+		range: [firstToken.range[0], lastToken.range[1]],
+		loc: {
+			start: firstToken.loc.start,
+			end: lastToken.loc.end
+		}
+	};
+}
+/**
+* Parse the table delimiter row from the text.
+*/
+function parseTableDelimiterRowFromText(text) {
+	const cursor = new ForwardCharacterCursor(text);
+	cursor.skipSpaces();
+	while (cursor.curr() === ">") {
+		cursor.next();
+		cursor.skipSpaces();
+	}
+	const delimiters = [];
+	let pipe = consumePipe();
+	while (!cursor.finished()) {
+		const delimiterStart = cursor.currIndex();
+		cursor.skipUntilEnd((c) => c === "|" || isSpaceOrTab(c) || c === "\n" || c === "\r");
+		const delimiterRange = [delimiterStart, cursor.currIndex()];
+		const delimiterText = text.slice(...delimiterRange);
+		if (!/^:?-+:?$/u.test(delimiterText)) return null;
+		if (delimiters.length > 0 && pipe == null) return null;
+		delimiters.push({
+			leadingPipe: pipe,
+			delimiter: {
+				text: delimiterText,
+				range: delimiterRange
+			}
+		});
+		pipe = consumePipe();
+	}
+	return {
+		delimiters,
+		trailingPipe: pipe
+	};
+	/**
+	* Consume a pipe if exists.
+	*/
+	function consumePipe() {
+		cursor.skipSpaces();
+		if (cursor.curr() === "|") {
+			const pipeStart = cursor.currIndex();
+			cursor.next();
+			const pipeRange = [pipeStart, cursor.currIndex()];
+			const result = {
+				text: text.slice(...pipeRange),
+				range: pipeRange
+			};
+			cursor.skipSpaces();
+			return result;
+		}
+		return null;
+	}
+}
+
 //#endregion
 //#region src/rules/no-multi-spaces.ts
 var no_multi_spaces_default = createRule("no-multi-spaces", {
@@ -7238,7 +7440,7 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 		docs: {
 			description: "disallow multiple spaces",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -7258,7 +7460,8 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			linkReference: verifyLinkReference,
 			listItem: verifyListItem,
 			blockquote: processBlockquote,
-			text: verifyText
+			text: verifyText,
+			table: verifyTable
 		};
 		/**
 		* Verify a text node.
@@ -7267,6 +7470,14 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			verifyTextInNode(node);
 		}
 		/**
+		* Verify a table node.
+		*/
+		function verifyTable(node) {
+			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
+			if (!parsedDelimiterRow) return;
+			verifyTextInRange(node, parsedDelimiterRow.range);
+		}
+		/**
 		* Verify a definition node.
 		*/
 		function verifyLinkDefinition(node) {
@@ -7442,7 +7653,7 @@ var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
 		docs: {
 			description: "disallow multiple empty lines in Markdown files.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -7601,7 +7812,7 @@ var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebrea
 		docs: {
 			description: "disallow text backslash at the end of a line.",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: void 0,
 		hasSuggestions: true,
@@ -7646,7 +7857,7 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 		docs: {
 			description: "disallow trailing whitespace at the end of lines in Markdown files.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -7772,7 +7983,7 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 		docs: {
 			description: "enforce that ordered list markers use sequential numbers",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: true,
@@ -7986,7 +8197,7 @@ function markerToKind(marker) {
 /**
 * Parse rule options.
 */
-function parseOptions(options) {
+function parseOptions$1(options) {
 	const prefer = markerToKind(options.prefer) || ".";
 	const overrides = (options.overrides ?? []).map((override) => {
 		const preferForOverride = markerToKind(override.prefer) || ".";
@@ -8013,7 +8224,7 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 		docs: {
 			description: "enforce consistent ordered list marker style",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8047,7 +8258,7 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions(context.options[0] || {});
+		const options = parseOptions$1(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -8232,7 +8443,7 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 		docs: {
 			description: "require or disallow padding lines between blocks",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -8430,7 +8641,7 @@ var prefer_autolinks_default = createRule("prefer-autolinks", {
 		docs: {
 			description: "enforce the use of autolinks for URLs",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8468,7 +8679,7 @@ var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks",
 		docs: {
 			description: "enforce the use of fenced code blocks over indented code blocks",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8698,7 +8909,7 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 		docs: {
 			description: "enforce using link reference definitions instead of inline links",
 			categories: [],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8977,9 +9188,9 @@ var setext_heading_underline_length_default = createRule("setext-heading-underli
 		docs: {
 			description: "enforce setext heading underline length",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
-		fixable: "whitespace",
+		fixable: "code",
 		schema: [{
 			type: "object",
 			properties: {
@@ -9215,7 +9426,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 		docs: {
 			description: "enforce a specific order for link definitions and footnote definitions",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -9488,7 +9699,7 @@ var strikethrough_delimiters_style_default = createRule("strikethrough-delimiter
 		docs: {
 			description: "enforce a consistent delimiter style for strikethrough",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -9655,6 +9866,724 @@ var table_header_casing_default = createRule("table-header-casing", {
 	}
 });
 
+//#endregion
+//#region src/rules/table-leading-trailing-pipes.ts
+var table_leading_trailing_pipes_default = createRule("table-leading-trailing-pipes", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent use of leading and trailing pipes in tables.",
+			categories: ["standard"],
+			listCategory: "Decorative"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{ anyOf: [{ enum: ["always", "never"] }, {
+			type: "object",
+			properties: {
+				leading: { enum: ["always", "never"] },
+				trailing: { enum: ["always", "never"] }
+			},
+			additionalProperties: false
+		}] }],
+		messages: {
+			missingLeadingPipe: "Table line should start with a leading pipe.",
+			unexpectedLeadingPipe: "Table line should not start with a leading pipe.",
+			missingTrailingPipe: "Table line should end with a trailing pipe.",
+			unexpectedTrailingPipe: "Table line should not end with a trailing pipe."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const preferOption = context.options[0] ?? "always";
+		const leadingOption = typeof preferOption === "string" ? preferOption : preferOption.leading ?? "always";
+		const trailingOption = typeof preferOption === "string" ? preferOption : preferOption.trailing ?? "always";
+		/**
+		* Verify the table pipes
+		*/
+		function verifyTablePipes(node) {
+			for (const row of node.children) verifyTableRowPipes(row);
+			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
+			if (parsedDelimiterRow) verifyTableLinePipes(parsedDelimiterRow.range, parsedDelimiterRow.loc, parsedDelimiterRow.delimiters.length);
+		}
+		/**
+		* Verify the table row pipes
+		*/
+		function verifyTableRowPipes(node) {
+			const loc = sourceCode.getLoc(node);
+			const range = sourceCode.getRange(node);
+			verifyTableLinePipes(range, loc, node.children.length);
+		}
+		/**
+		* Verify the table line pipes
+		*/
+		function verifyTableLinePipes(lineContentRange, lineLocation, columnCount) {
+			verifyTableLeadingPipe(lineContentRange, lineLocation, columnCount);
+			verifyTableTrailingPipe(lineContentRange, lineLocation, columnCount);
+		}
+		/**
+		* Verify the table leading pipe
+		*/
+		function verifyTableLeadingPipe(lineContentRange, lineLocation, columnCount) {
+			if (leadingOption === "always") {
+				if (sourceCode.text.startsWith("|", lineContentRange[0])) return;
+				context.report({
+					messageId: "missingLeadingPipe",
+					loc: lineLocation.start,
+					fix(fixer) {
+						return fixer.insertTextBeforeRange(lineContentRange, "| ");
+					}
+				});
+			} else if (leadingOption === "never") {
+				if (columnCount < 2) {
+					if (!(trailingOption === "always" && sourceCode.text.endsWith("|", lineContentRange[1]))) return;
+				}
+				if (!sourceCode.text.startsWith("|", lineContentRange[0])) return;
+				let endIndex = lineContentRange[0] + 1;
+				while (endIndex < lineContentRange[1] && isSpaceOrTab(sourceCode.text[endIndex])) endIndex++;
+				context.report({
+					messageId: "unexpectedLeadingPipe",
+					loc: {
+						start: lineLocation.start,
+						end: {
+							line: lineLocation.start.line,
+							column: lineLocation.start.column + (endIndex - lineContentRange[0])
+						}
+					},
+					fix(fixer) {
+						return fixer.removeRange([lineContentRange[0], endIndex]);
+					}
+				});
+			}
+		}
+		/**
+		* Verify the table trailing pipe
+		*/
+		function verifyTableTrailingPipe(lineContentRange, lineLocation, columnCount) {
+			if (trailingOption === "always") {
+				if (sourceCode.text.endsWith("|", lineContentRange[1])) return;
+				context.report({
+					messageId: "missingTrailingPipe",
+					loc: lineLocation.end,
+					fix(fixer) {
+						return fixer.insertTextAfterRange(lineContentRange, " |");
+					}
+				});
+			} else if (trailingOption === "never") {
+				if (columnCount < 2) {
+					if (!(leadingOption === "always" && sourceCode.text.startsWith("|", lineContentRange[0]))) return;
+				}
+				if (!sourceCode.text.endsWith("|", lineContentRange[1])) return;
+				let startIndex = lineContentRange[1] - 1;
+				while (startIndex - 1 > lineContentRange[0] && isSpaceOrTab(sourceCode.text[startIndex - 1])) startIndex--;
+				context.report({
+					messageId: "unexpectedTrailingPipe",
+					loc: {
+						start: {
+							line: lineLocation.end.line,
+							column: lineLocation.end.column - (lineContentRange[1] - startIndex)
+						},
+						end: lineLocation.end
+					},
+					fix(fixer) {
+						return fixer.removeRange([startIndex, lineContentRange[1]]);
+					}
+				});
+			}
+		}
+		return { table(node) {
+			verifyTablePipes(node);
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/table-pipe-alignment.ts
+var table_pipe_alignment_default = createRule("table-pipe-alignment", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent alignment of table pipes",
+			categories: ["standard"],
+			listCategory: "Decorative"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { column: { enum: ["minimum", "consistent"] } },
+			additionalProperties: false
+		}],
+		messages: {
+			addSpaces: "Table pipe should be aligned at column {{expected}} (add {{count}} character{{plural}}).",
+			removeSpaces: "Table pipe should be aligned at column {{expected}} (remove {{count}} character{{plural}})."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const columnOption = (context.options[0] || {}).column || "minimum";
+		/**
+		* 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;
+			}
+		}
+		/**
+		* Verify the pipe in the row
+		*/
+		function verifyRowPipe(row, pipeIndex, expected) {
+			let cellIndex;
+			let pipe;
+			if (pipeIndex === 0) {
+				cellIndex = 0;
+				pipe = "leadingPipe";
+			} else {
+				cellIndex = pipeIndex - 1;
+				pipe = "trailingPipe";
+			}
+			if (row.cells.length <= cellIndex) return true;
+			const cell = row.cells[cellIndex];
+			const pipeToken = cell[pipe];
+			if (!pipeToken) return true;
+			return verifyPipe(pipeToken, expected, {
+				cell,
+				pipeIndex
+			});
+		}
+		/**
+		* Verify the pipe position
+		*/
+		function verifyPipe(pipe, expected, ctx) {
+			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;
+			context.report({
+				loc: pipe.loc,
+				messageId: diff > 0 ? "addSpaces" : "removeSpaces",
+				data: {
+					expected: String(expected),
+					count: String(Math.abs(diff)),
+					plural: Math.abs(diff) === 1 ? "" : "s"
+				},
+				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));
+					}
+					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);
+					const widthBeforeDelimiter = getTextWidth(beforeDelimiter);
+					const newLength = expected - widthBeforeDelimiter;
+					const minimumDelimiterLength = getMinimumDelimiterLength(ctx.cell.align);
+					const spaceAfter = isNeedSpaceAfterContent(ctx.cell) ? " " : "";
+					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 newDelimiter = "-".repeat(newLength - delimiterPrefix.length - delimiterSuffix.length);
+					return fixer.replaceTextRange([ctx.cell.delimiter.range[0], pipe.range[0]], delimiterPrefix + newDelimiter + delimiterSuffix);
+					/**
+					* Fixer to remove spaces before the pipe
+					*/
+					function fixRemoveSpaces() {
+						const beforePipe = sourceCode.lines[pipe.loc.start.line - 1].slice(0, pipe.loc.start.column - 1);
+						const trimmedBeforePipe = beforePipe.trimEnd();
+						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;
+						return fixer.replaceTextRange([pipe.range[0] - spacesBeforePipeLength, pipe.range[0]], " ".repeat(newSpacesLength));
+					}
+				}
+			});
+			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);
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/table-pipe-spacing.ts
+/**
+* Parsed options
+*/
+function parseOptions(options) {
+	const spaceOption = options?.space;
+	const leadingSpace = (typeof spaceOption === "object" ? spaceOption.leading : spaceOption) || "always";
+	const trailingSpace = (typeof spaceOption === "object" ? spaceOption.trailing : spaceOption) || "always";
+	const cellAlignOption = options?.cellAlign;
+	const defaultDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.defaultDelimiter : cellAlignOption) || "left";
+	const leftAlignmentDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.leftAlignmentDelimiter : cellAlignOption) || "left";
+	const centerAlignmentDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.centerAlignmentDelimiter : cellAlignOption) || "center";
+	const rightAlignmentDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.rightAlignmentDelimiter : cellAlignOption) || "right";
+	return {
+		leadingSpace,
+		trailingSpace,
+		cellAlignByDelimiter: {
+			none: adjustAlign(defaultDelimiterCellAlign),
+			left: adjustAlign(leftAlignmentDelimiterCellAlign),
+			center: adjustAlign(centerAlignmentDelimiterCellAlign),
+			right: adjustAlign(rightAlignmentDelimiterCellAlign)
+		}
+	};
+	/**
+	* Adjust the alignment option based on the spacing options.
+	*/
+	function adjustAlign(align) {
+		if (align === "left") {
+			if (trailingSpace === "always") return "left";
+			return "ignore";
+		}
+		if (align === "center") {
+			if (leadingSpace === "always" && trailingSpace === "always") return "center";
+			return "ignore";
+		}
+		if (align === "right") {
+			if (leadingSpace === "always") return "right";
+			return "ignore";
+		}
+		return align;
+	}
+}
+var table_pipe_spacing_default = createRule("table-pipe-spacing", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent spacing around table pipes",
+			categories: ["standard"],
+			listCategory: "Whitespace"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				space: { anyOf: [{ enum: ["always", "never"] }, {
+					type: "object",
+					properties: {
+						leading: { enum: ["always", "never"] },
+						trailing: { enum: ["always", "never"] }
+					},
+					additionalProperties: false
+				}] },
+				cellAlign: { anyOf: [{ enum: [
+					"left",
+					"center",
+					"right"
+				] }, {
+					type: "object",
+					properties: {
+						defaultDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] },
+						leftAlignmentDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] },
+						centerAlignmentDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] },
+						rightAlignmentDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] }
+					},
+					additionalProperties: false
+				}] }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedSpaceBefore: "Expected 1 space before \"|\".",
+			expectedNoSpaceBefore: "Expected no space before \"|\".",
+			expectedSpaceAfter: "Expected 1 space after \"|\".",
+			expectedNoSpaceAfter: "Expected no space after \"|\".",
+			expectedAlignLeft: "Expected 1 space after \"|\" for left-aligned column.",
+			expectedNoSpaceAlignLeft: "Expected no space after \"|\" for left-aligned column.",
+			expectedAlignRight: "Expected 1 space before \"|\" for right-aligned column.",
+			expectedNoSpaceAlignRight: "Expected no space before \"|\" for right-aligned column.",
+			expectedAlignCenter: "Expected the number of spaces before and after the content to be the same or differ by 1 at most for center-aligned column."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = parseOptions(context.options[0]);
+		/**
+		* Verify for the leading pipe.
+		*/
+		function verifyLeadingPipe(pipe, nextToken) {
+			if (options.leadingSpace === "always") {
+				if (pipe.range[1] < nextToken.range[0]) return true;
+				context.report({
+					loc: pipe.loc,
+					messageId: "expectedSpaceAfter",
+					fix(fixer) {
+						return fixer.insertTextAfterRange(pipe.range, " ");
+					}
+				});
+				return false;
+			} else if (options.leadingSpace === "never") {
+				if (pipe.range[1] === nextToken.range[0]) return true;
+				context.report({
+					loc: {
+						start: pipe.loc.end,
+						end: nextToken.loc.start
+					},
+					messageId: "expectedNoSpaceAfter",
+					fix(fixer) {
+						return fixer.removeRange([pipe.range[1], nextToken.range[0]]);
+					}
+				});
+				return false;
+			}
+			return true;
+		}
+		/**
+		* Verify for the trailing pipe.
+		*/
+		function verifyTrailingPipe(prevToken, pipe) {
+			if (options.trailingSpace === "always") {
+				if (prevToken.range[1] < pipe.range[0]) return true;
+				context.report({
+					loc: pipe.loc,
+					messageId: "expectedSpaceBefore",
+					fix(fixer) {
+						return fixer.insertTextBeforeRange(pipe.range, " ");
+					}
+				});
+				return false;
+			} else if (options.trailingSpace === "never") {
+				if (prevToken.range[1] === pipe.range[0]) return true;
+				context.report({
+					loc: {
+						start: prevToken.loc.end,
+						end: pipe.loc.start
+					},
+					messageId: "expectedNoSpaceBefore",
+					fix(fixer) {
+						return fixer.removeRange([prevToken.range[1], pipe.range[0]]);
+					}
+				});
+				return false;
+			}
+			return true;
+		}
+		/**
+		* Verify for the alignment of the pipe according to the delimiter alignment.
+		* Return "leading" if the leading pipe is reported, "trailing" if the trailing pipe is reported, "both" if both are reported, or null if nothing is reported.
+		*/
+		function verifyAlignPipe({ leadingPipe, content, trailingPipe }, cellAlign) {
+			if (!leadingPipe || !trailingPipe || !content) return null;
+			const lineText = sourceCode.lines[leadingPipe.loc.start.line - 1];
+			if (cellAlign === "left") {
+				const expectedWidth = options.leadingSpace === "always" ? 1 : 0;
+				if (getLeadingSpacesWidth() === expectedWidth) return null;
+				context.report({
+					loc: leadingPipe.range[1] < content.range[0] ? {
+						start: leadingPipe.loc.end,
+						end: content.loc.start
+					} : leadingPipe.loc,
+					messageId: expectedWidth >= 1 ? "expectedAlignLeft" : "expectedNoSpaceAlignLeft",
+					*fix(fixer) {
+						const cellWidth = getCellWidth();
+						const contentTextWidth = getContentTextWidth();
+						const newLeadingSpaces = " ".repeat(expectedWidth);
+						const newTrailingSpaces = " ".repeat(Math.max(cellWidth - contentTextWidth - expectedWidth, 0));
+						const contentText = getNormalizedContentText();
+						yield fixer.replaceTextRange([leadingPipe.range[1], trailingPipe.range[0]], `${newLeadingSpaces}${contentText}${newTrailingSpaces}`);
+					}
+				});
+				return "leading";
+			} else if (cellAlign === "right") {
+				const expectedWidth = options.trailingSpace === "always" ? 1 : 0;
+				if (getTrailingSpacesWidth() === expectedWidth) return null;
+				context.report({
+					loc: content.range[1] < trailingPipe.range[0] ? {
+						start: content.loc.end,
+						end: trailingPipe.loc.start
+					} : trailingPipe.loc,
+					messageId: expectedWidth >= 1 ? "expectedAlignRight" : "expectedNoSpaceAlignRight",
+					*fix(fixer) {
+						const cellWidth = getCellWidth();
+						const contentTextWidth = getContentTextWidth();
+						const newLeadingSpaces = " ".repeat(Math.max(cellWidth - contentTextWidth - expectedWidth, 0));
+						const newTrailingSpaces = " ".repeat(expectedWidth);
+						const contentText = getNormalizedContentText();
+						yield fixer.replaceTextRange([leadingPipe.range[1], trailingPipe.range[0]], `${newLeadingSpaces}${contentText}${newTrailingSpaces}`);
+					}
+				});
+				return "trailing";
+			} else if (cellAlign === "center") {
+				const leadingSpacesWidth = getLeadingSpacesWidth();
+				const trailingSpacesWidth = getTrailingSpacesWidth();
+				if (leadingSpacesWidth === trailingSpacesWidth || leadingSpacesWidth + 1 === trailingSpacesWidth) return null;
+				const leadingReportLoc = leadingPipe.range[1] < content.range[0] ? {
+					start: leadingPipe.loc.end,
+					end: content.loc.start
+				} : leadingPipe.loc;
+				const trailingReportLoc = content.range[1] < trailingPipe.range[0] ? {
+					start: content.loc.end,
+					end: trailingPipe.loc.start
+				} : trailingPipe.loc;
+				for (const reportLoc of [leadingReportLoc, trailingReportLoc]) context.report({
+					loc: reportLoc,
+					messageId: "expectedAlignCenter",
+					*fix(fixer) {
+						const cellWidth = getCellWidth();
+						const contentTextWidth = getContentTextWidth();
+						const spacesLength = cellWidth - contentTextWidth;
+						const leadingSpacesLength = Math.floor(spacesLength / 2);
+						const trailingSpacesLength = spacesLength - leadingSpacesLength;
+						const newLeadingSpaces = " ".repeat(leadingSpacesLength);
+						const newTrailingSpaces = " ".repeat(trailingSpacesLength);
+						const contentText = getNormalizedContentText();
+						yield fixer.replaceTextRange([leadingPipe.range[1], trailingPipe.range[0]], `${newLeadingSpaces}${contentText}${newTrailingSpaces}`);
+					}
+				});
+				return "both";
+			}
+			return null;
+			/**
+			* Get the width of the leading spaces in the cell.
+			*/
+			function getLeadingSpacesWidth() {
+				return getTextWidth(lineText, leadingPipe.loc.end.column - 1, content.loc.start.column - 1);
+			}
+			/**
+			* Get the width of the trailing spaces in the cell.
+			*/
+			function getTrailingSpacesWidth() {
+				return getTextWidth(lineText, content.loc.end.column - 1, trailingPipe.loc.start.column - 1);
+			}
+			/**
+			* Get the width of the whole cell (including leading and trailing spaces)
+			*/
+			function getCellWidth() {
+				return getTextWidth(lineText, leadingPipe.loc.end.column - 1, trailingPipe.loc.start.column - 1);
+			}
+			/**
+			* Get the width of the content text (excluding leading and trailing spaces)
+			*/
+			function getContentTextWidth() {
+				return getTextWidth(lineText, content.loc.start.column - 1, content.loc.end.column - 1);
+			}
+			/**
+			* Get the normalized content text (with normalized spaces)
+			*/
+			function getNormalizedContentText() {
+				const prefixWidth = getWidth(lineText.slice(0, content.loc.start.column - 1));
+				let result = "";
+				for (const c of lineText.slice(content.loc.start.column - 1, content.loc.end.column - 1)) if (c === "	") result += " ".repeat(4 - (prefixWidth + result.length) % 4);
+				else result += c;
+				return result;
+			}
+		}
+		/**
+		* Convert a parsed table row to cell data list
+		*/
+		function parsedTableRowToCellDataList(parsedRow) {
+			return 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 delimiter data list
+		*/
+		function parsedTableDelimiterRowToDelimiterDataList(parsedDelimiterRow) {
+			return parsedDelimiterRow.delimiters.map((cell, index) => {
+				const nextCell = index + 1 < parsedDelimiterRow.delimiters.length ? parsedDelimiterRow.delimiters[index + 1] : null;
+				return {
+					type: "delimiter",
+					leadingPipe: cell.leadingPipe,
+					content: cell.delimiter,
+					align: cell.delimiter.align,
+					trailingPipe: nextCell ? nextCell.leadingPipe : parsedDelimiterRow.trailingPipe
+				};
+			});
+		}
+		return { table(node) {
+			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
+			const delimiters = parsedDelimiterRow && parsedTableDelimiterRowToDelimiterDataList(parsedDelimiterRow);
+			for (const row of node.children) {
+				const parsedRow = parseTableRow(sourceCode, row);
+				if (!parsedRow) continue;
+				const cells = parsedTableRowToCellDataList(parsedRow);
+				for (let columnIndex = 0; columnIndex < cells.length; columnIndex++) {
+					const cell = cells[columnIndex];
+					const delimiter = delimiters && columnIndex < delimiters.length ? delimiters[columnIndex] : null;
+					const alignReportedPoint = delimiter ? verifyAlignPipe(cell, options.cellAlignByDelimiter[delimiter.align]) : null;
+					if (alignReportedPoint === "both") continue;
+					if (cell.leadingPipe && alignReportedPoint !== "leading") {
+						if (options.leadingSpace !== "never" || cell.content) {
+							const nextToken = getNextToken(cells, columnIndex);
+							if (nextToken) verifyLeadingPipe(cell.leadingPipe, nextToken);
+						}
+					}
+					if (cell.trailingPipe && options.trailingSpace !== "never" && alignReportedPoint !== "trailing") {
+						const prevToken = getPrevToken(cells, columnIndex);
+						if (prevToken) verifyTrailingPipe(prevToken, cell.trailingPipe);
+					}
+				}
+			}
+			if (!delimiters) return;
+			for (let columnIndex = 0; columnIndex < delimiters.length; columnIndex++) {
+				const delimiter = delimiters[columnIndex];
+				const alignReportedPoint = verifyAlignPipe(delimiter, options.cellAlignByDelimiter[delimiter.align]);
+				if (alignReportedPoint === "both") continue;
+				if (delimiter.leadingPipe && alignReportedPoint !== "leading") verifyLeadingPipe(delimiter.leadingPipe, delimiter.content);
+				if (delimiter.trailingPipe && alignReportedPoint !== "trailing") verifyTrailingPipe(delimiter.content, delimiter.trailingPipe);
+			}
+		} };
+		/**
+		* Get the next token (pipe or cell) after the given column index.
+		*/
+		function getNextToken(cells, columnIndex) {
+			for (let i = columnIndex; i < cells.length; i++) {
+				const cell = cells[i];
+				const token = cell.content ?? cell.trailingPipe;
+				if (token) return token;
+			}
+			return null;
+		}
+		/**
+		* Get the prev token (pipe or cell) after the given column index.
+		*/
+		function getPrevToken(cells, columnIndex) {
+			for (let i = columnIndex; i >= 0; i--) {
+				const cell = cells[i];
+				const token = cell.content ?? cell.leadingPipe;
+				if (token) return token;
+			}
+			return null;
+		}
+	}
+});
+
 //#endregion
 //#region src/rules/thematic-break-character-style.ts
 var thematic_break_character_style_default = createRule("thematic-break-character-style", {
@@ -9663,7 +10592,7 @@ var thematic_break_character_style_default = createRule("thematic-break-characte
 		docs: {
 			description: "enforce consistent character style for thematic breaks (horizontal rules) in Markdown.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -9742,7 +10671,7 @@ var thematic_break_length_default = createRule("thematic-break-length", {
 		docs: {
 			description: "enforce consistent length for thematic breaks (horizontal rules) in Markdown.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -9808,7 +10737,7 @@ var thematic_break_sequence_pattern_default = createRule("thematic-break-sequenc
 		docs: {
 			description: "enforce consistent repeating patterns for thematic breaks (horizontal rules) in Markdown.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -9905,6 +10834,9 @@ const rules$1 = [
 	sort_definitions_default,
 	strikethrough_delimiters_style_default,
 	table_header_casing_default,
+	table_leading_trailing_pipes_default,
+	table_pipe_alignment_default,
+	table_pipe_spacing_default,
 	thematic_break_character_style_default,
 	thematic_break_length_default,
 	thematic_break_sequence_pattern_default
@@ -9993,6 +10925,9 @@ const rules$2 = {
 	"markdown-preferences/setext-heading-underline-length": "error",
 	"markdown-preferences/sort-definitions": "error",
 	"markdown-preferences/strikethrough-delimiters-style": "error",
+	"markdown-preferences/table-leading-trailing-pipes": "error",
+	"markdown-preferences/table-pipe-alignment": "error",
+	"markdown-preferences/table-pipe-spacing": "error",
 	"markdown-preferences/thematic-break-character-style": "error",
 	"markdown-preferences/thematic-break-length": "error",
 	"markdown-preferences/thematic-break-sequence-pattern": "error"
@@ -10005,7 +10940,7 @@ var meta_exports = __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.24.0";
+const version = "0.25.0";
 
 //#endregion
 //#region src/index.ts