eslint-plugin-markdown-preferences 0.24.0 → 0.26.0

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) {
@@ -109,13 +129,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 +391,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 +421,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 +559,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 +735,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 +818,7 @@ function getOtherMarker(unavailableMarker) {
 /**
 * Parse rule options.
 */
-function parseOptions$3(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}").`);
@@ -815,7 +850,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 +886,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$5(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -1114,7 +1149,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 +1286,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,
@@ -1292,41 +1327,265 @@ 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",
 		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,
-		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]]);
+			let insertText = sourceCode.text.slice(rangeStart, lineStart) + sourceCode.text.slice(...range);
+			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);
+			}
+		};
 	}
 });
 
@@ -3422,7 +3681,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 +3863,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 +5296,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 +5310,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 +5349,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 +6298,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 +6375,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 +6452,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 +6477,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$6(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$4(option) {
+		function parseOptions$6(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (bracketsRange) => {
@@ -6353,7 +6612,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 +6641,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 +6662,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 +6805,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 +6930,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 +6955,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$6(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$4(option) {
+		function parseOptions$6(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (openingParenIndex, closingParenIndex) => {
@@ -6815,7 +7074,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 +7209,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 +7291,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 +7390,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 +7489,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 +7684,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 +7704,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 +7714,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 +7897,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 +8056,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 +8101,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 +8227,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 +8441,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 +8468,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 +8502,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 +8687,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 +8885,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 +8923,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 +9153,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 +9432,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 +9670,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 +9943,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 +10110,759 @@ 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";
+		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(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, table) {
+			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, pipeIndex, table, cell);
+		}
+		/**
+		* Verify the pipe position
+		*/
+		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;
+			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 (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 (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(cell.align);
+					const spaceAfter = table.hasSpaceBetweenContentAndTrailingPipe(pipeIndex) ? " " : "";
+					if (newLength < minimumDelimiterLength + spaceAfter.length) return null;
+					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([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 < (table.hasSpaceBetweenContentAndTrailingPipe(pipeIndex) ? 1 : 0)) return null;
+						return fixer.replaceTextRange([pipe.range[0] - spacesBeforePipeLength, pipe.range[0]], " ".repeat(newSpacesLength));
+					}
+				}
+			});
+			return false;
+		}
+		/**
+		* Get the minimum delimiter length based on alignment
+		*/
+		function getMinimumDelimiterLength(align) {
+			return align === "none" ? 1 : align === "center" ? 3 : 2;
+		}
+		return { table(node) {
+			const parsed = parseTable(sourceCode, node);
+			if (!parsed) return;
+			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
+/**
+* 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 +10871,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 +10950,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 +11016,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 +11113,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
@@ -9912,7 +11123,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,
@@ -9942,7 +11153,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,
@@ -9993,6 +11204,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"
@@ -10000,12 +11214,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.24.0";
+const version = "0.26.0";
 
 //#endregion
 //#region src/index.ts