eslint-plugin-markdown-preferences 0.28.0 → 0.29.1

package/README.md

@@ -13,17 +13,15 @@ A specialized ESLint plugin that helps enforce consistent writing style and form
 
 ## 📛 Features
 
-- 📝 **Comprehensive style enforcement**\
-  Unifies document expression and description style: heading casing, table header casing, inline code/link usage, emoji notation, and more.
-- 🧩 **Notation and formatting consistency**\
-  Standardizes Markdown notation: list markers, code fences, link/reference style, thematic breaks, and table formatting.
-- 🎨 **Whitespace and decorative rules**\
-  Controls indentation, spacing, line breaks, trailing spaces, and decorative elements for clean, readable Markdown.
-- 🔧 **Auto-fix support**\
-  Most rules support ESLint's `--fix` option for effortless formatting and correction.
-- ⚙️ **Flexible configuration**\
-  Provides both "recommended" and "standard" configs, and allows you to finely customize formatting and rules to suit your preferences and Markdown style.
-- 🌐 **Live demo & documentation**\
+- 📝 **Comprehensive style enforcement**
+  Enforces consistent heading casing, table header casing, inline code/link usage, emoji notation, and more for unified document style.
+- 🧩 **Powerful formatting consistency**
+  Strongly standardizes Markdown formatting: whitespace, indentation, spacing, line breaks, list markers, code fences, links, references, thematic breaks, tables, and decorative elements—ensuring documents are clean and uniform.
+- 🚀 **Extended Markdown syntax support**
+  Supports custom containers, mathematical expressions, and other extended syntax for high compatibility with VitePress.
+- 🔧 **Auto-fix support**
+  Most rules support ESLint's `--fix` option for automatic correction.
+- 🌐 **Online Demo & Documentation**
   Try it instantly in the [Online Demo](https://eslint-online-playground.netlify.app/#eslint-plugin-markdown-preferences) and see [full documentation][documentation site].
 
 <!--DOCS_IGNORE_START-->
@@ -164,25 +162,25 @@ The rules with the following 💄 are included in the `standard` config.
 
 <!-- prettier-ignore-start -->
 
-| Rule ID                                                                                                                                                               | Description                                                                               | Fixable | Config |
-| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- | :-----: | :----: |
-| [markdown-preferences/bullet-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/bullet-list-marker-style.html)                   | enforce consistent bullet list (unordered list) marker style                              |   🔧    |   💄   |
-| [markdown-preferences/code-fence-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html)                                   | enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks. |   🔧    |   💄   |
-| [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html)                                   | require link definitions and footnote definitions to be placed at the end of the document |   🔧    |        |
-| [markdown-preferences/emphasis-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emphasis-delimiters-style.html)                 | enforce a consistent delimiter style for emphasis and strong emphasis                     |   🔧    |   💄   |
-| [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html)                           | enforce consistent hard linebreak style.                                                  |   🔧    |  ⭐💄  |
-| [markdown-preferences/level1-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level1-heading-style.html)                           | enforce consistent style for level 1 headings                                             |   🔧    |   💄   |
-| [markdown-preferences/level2-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level2-heading-style.html)                           | enforce consistent style for level 2 headings                                             |   🔧    |   💄   |
-| [markdown-preferences/link-destination-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-destination-style.html)                       | enforce a consistent style for link destinations                                          |   🔧    |   💄   |
-| [markdown-preferences/link-title-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-title-style.html)                                   | enforce a consistent style for link titles                                                |   🔧    |   💄   |
-| [markdown-preferences/no-implicit-block-closing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-implicit-block-closing.html)                 | disallow implicit block closing for fenced code blocks, math blocks, and custom blocks    |   🔧    |  ⭐💄  |
-| [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html)             | disallow text backslash at the end of a line.                                             |         |  ⭐💄  |
-| [markdown-preferences/ordered-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html)                 | enforce consistent ordered list marker style                                              |   🔧    |   💄   |
-| [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html)                                   | enforce the use of autolinks for URLs                                                     |   🔧    |  ⭐💄  |
-| [markdown-preferences/prefer-fenced-code-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html)                 | enforce the use of fenced code blocks over indented code blocks                           |   🔧    |  ⭐💄  |
-| [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links                          |   🔧    |        |
-| [markdown-preferences/strikethrough-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/strikethrough-delimiters-style.html)       | enforce a consistent delimiter style for strikethrough                                    |   🔧    |   💄   |
-| [markdown-preferences/thematic-break-character-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-character-style.html)       | enforce consistent character style for thematic breaks (horizontal rules) in Markdown.    |   🔧    |   💄   |
+| Rule ID                                                                                                                                                               | Description                                                                                | Fixable | Config |
+| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------- | :-----: | :----: |
+| [markdown-preferences/bullet-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/bullet-list-marker-style.html)                   | enforce consistent bullet list (unordered list) marker style                               |   🔧    |   💄   |
+| [markdown-preferences/code-fence-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html)                                   | enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.  |   🔧    |   💄   |
+| [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html)                                   | require link definitions and footnote definitions to be placed at the end of the document  |   🔧    |        |
+| [markdown-preferences/emphasis-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emphasis-delimiters-style.html)                 | enforce a consistent delimiter style for emphasis and strong emphasis                      |   🔧    |   💄   |
+| [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html)                           | enforce consistent hard linebreak style.                                                   |   🔧    |  ⭐💄  |
+| [markdown-preferences/level1-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level1-heading-style.html)                           | enforce consistent style for level 1 headings                                              |   🔧    |   💄   |
+| [markdown-preferences/level2-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level2-heading-style.html)                           | enforce consistent style for level 2 headings                                              |   🔧    |   💄   |
+| [markdown-preferences/link-destination-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-destination-style.html)                       | enforce a consistent style for link destinations                                           |   🔧    |   💄   |
+| [markdown-preferences/link-title-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-title-style.html)                                   | enforce a consistent style for link titles                                                 |   🔧    |   💄   |
+| [markdown-preferences/no-implicit-block-closing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-implicit-block-closing.html)                 | disallow implicit block closing for fenced code blocks, math blocks, and custom containers |   🔧    |  ⭐💄  |
+| [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html)             | disallow text backslash at the end of a line.                                              |         |  ⭐💄  |
+| [markdown-preferences/ordered-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html)                 | enforce consistent ordered list marker style                                               |   🔧    |   💄   |
+| [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html)                                   | enforce the use of autolinks for URLs                                                      |   🔧    |  ⭐💄  |
+| [markdown-preferences/prefer-fenced-code-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html)                 | enforce the use of fenced code blocks over indented code blocks                            |   🔧    |  ⭐💄  |
+| [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links                           |   🔧    |        |
+| [markdown-preferences/strikethrough-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/strikethrough-delimiters-style.html)       | enforce a consistent delimiter style for strikethrough                                     |   🔧    |   💄   |
+| [markdown-preferences/thematic-break-character-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-character-style.html)       | enforce consistent character style for thematic breaks (horizontal rules) in Markdown.     |   🔧    |   💄   |
 
 <!-- prettier-ignore-end -->
 
@@ -204,6 +202,7 @@ The rules with the following 💄 are included in the `standard` config.
 | [markdown-preferences/no-multi-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multi-spaces.html)                         | disallow multiple spaces                                             |   🔧    |   💄   |
 | [markdown-preferences/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html)         | disallow multiple empty lines in Markdown files.                     |   🔧    |   💄   |
 | [markdown-preferences/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html)                   | disallow trailing whitespace at the end of lines in Markdown files.  |   🔧    |   💄   |
+| [markdown-preferences/padded-custom-containers](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padded-custom-containers.html)       | disallow or require padding inside custom containers                 |   🔧    |   💄   |
 | [markdown-preferences/padding-line-between-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html) | require or disallow padding lines between blocks                     |   🔧    |   💄   |
 | [markdown-preferences/table-pipe-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-pipe-spacing.html)                   | enforce consistent spacing around table pipes                        |   🔧    |   💄   |
 

package/lib/index.d.ts

@@ -126,7 +126,7 @@ interface RuleOptions {
    */
   'markdown-preferences/list-marker-alignment'?: Linter.RuleEntry<MarkdownPreferencesListMarkerAlignment>;
   /**
-   * disallow implicit block closing for fenced code blocks, math blocks, and custom blocks
+   * disallow implicit block closing for fenced code blocks, math blocks, and custom containers
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-implicit-block-closing.html
    */
   'markdown-preferences/no-implicit-block-closing'?: Linter.RuleEntry<[]>;
@@ -170,6 +170,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html
    */
   'markdown-preferences/ordered-list-marker-style'?: Linter.RuleEntry<MarkdownPreferencesOrderedListMarkerStyle>;
+  /**
+   * disallow or require padding inside custom containers
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padded-custom-containers.html
+   */
+  'markdown-preferences/padded-custom-containers'?: Linter.RuleEntry<MarkdownPreferencesPaddedCustomContainers>;
   /**
    * require or disallow padding lines between blocks
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html
@@ -389,6 +394,9 @@ type MarkdownPreferencesOrderedListMarkerStyle = [] | [{
     prefer?: ("n." | "n)");
   }[];
 }];
+type MarkdownPreferencesPaddedCustomContainers = [] | [{
+  padding?: ("always" | "never");
+}];
 type MarkdownPreferencesPaddingLineBetweenBlocks = {
   prev: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"))[]] | {
     type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"))[]]);
@@ -508,7 +516,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.28.0";
+declare const version: "0.29.1";
 //#endregion
 //#region src/language/ast-types.d.ts
 type Node = mdast.Node;

package/lib/index.js

@@ -7617,7 +7617,7 @@ var no_implicit_block_closing_default = createRule("no-implicit-block-closing",
 	meta: {
 		type: "suggestion",
 		docs: {
-			description: "disallow implicit block closing for fenced code blocks, math blocks, and custom blocks",
+			description: "disallow implicit block closing for fenced code blocks, math blocks, and custom containers",
 			categories: ["recommended", "standard"],
 			listCategory: "Notation"
 		},
@@ -7636,7 +7636,8 @@ var no_implicit_block_closing_default = createRule("no-implicit-block-closing",
 			code(node) {
 				const parsed = parseFencedCodeBlock(sourceCode, node);
 				if (!parsed) return;
-				if (!parsed.closingFence) context.report({
+				if (parsed.closingFence) return;
+				context.report({
 					node,
 					loc: parsed.openingFence.loc,
 					messageId: "missingClosingFence",
@@ -7651,7 +7652,8 @@ var no_implicit_block_closing_default = createRule("no-implicit-block-closing",
 			math(node) {
 				const parsed = parseMathBlock(sourceCode, node);
 				if (!parsed) return;
-				if (!parsed.closingSequence) context.report({
+				if (parsed.closingSequence) return;
+				context.report({
 					node,
 					loc: parsed.openingSequence.loc,
 					messageId: "missingClosingMath",
@@ -7666,11 +7668,13 @@ var no_implicit_block_closing_default = createRule("no-implicit-block-closing",
 			customContainer(node) {
 				const parsed = parseCustomContainer(sourceCode, node);
 				if (!parsed) return;
-				if (!parsed.closingSequence) context.report({
+				if (parsed.closingSequence) return;
+				context.report({
 					node,
 					loc: parsed.openingSequence.loc,
 					messageId: "missingClosingContainer",
 					fix(fixer) {
+						if (withinSameLengthOpeningCustomContainer(sourceCode, node, parsed.openingSequence.text.length)) return null;
 						const openingLoc = parsed.openingSequence.loc;
 						const prefix = sourceCode.lines[openingLoc.start.line - 1].slice(0, openingLoc.start.column - 1).replace(/[^\s>]/gu, " ");
 						const closingSequence = parsed.openingSequence.text;
@@ -7681,6 +7685,23 @@ var no_implicit_block_closing_default = createRule("no-implicit-block-closing",
 		};
 	}
 });
+/**
+* Check if the given custom container node is within another custom container
+* that has the same length of opening sequence.
+*
+*/
+function withinSameLengthOpeningCustomContainer(sourceCode, node, openingLength) {
+	let current = getParent(sourceCode, node);
+	while (current) {
+		if (current.type === "customContainer") {
+			const parsed = parseCustomContainer(sourceCode, current);
+			if (!parsed) return true;
+			if (parsed.openingSequence.text.length === openingLength) return true;
+		}
+		current = getParent(sourceCode, current);
+	}
+	return false;
+}
 
 //#endregion
 //#region src/rules/no-laziness-blockquotes.ts
@@ -8922,6 +8943,101 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 	}
 });
 
+//#endregion
+//#region src/rules/padded-custom-containers.ts
+var padded_custom_containers_default = createRule("padded-custom-containers", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "disallow or require padding inside custom containers",
+			categories: ["standard"],
+			listCategory: "Whitespace"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { padding: {
+				type: "string",
+				enum: ["always", "never"],
+				default: "never"
+			} },
+			additionalProperties: false
+		}],
+		messages: {
+			expectedPaddingAfterOpeningMarker: "Expected padding after opening marker.",
+			expectedPaddingBeforeClosingMarker: "Expected padding before closing marker.",
+			unexpectedPaddingAfterOpeningMarker: "Unexpected padding after opening marker.",
+			unexpectedPaddingBeforeClosingMarker: "Unexpected padding before closing marker."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const padding = (context.options[0] || {}).padding || "never";
+		return { customContainer(node) {
+			if (node.children.length === 0) return;
+			const parsed = parseCustomContainer(sourceCode, node);
+			if (!parsed) return;
+			const { openingSequence, closingSequence } = parsed;
+			const firstChild = node.children[0];
+			const lastChild = node.children[node.children.length - 1];
+			const firstChildLoc = sourceCode.getLoc(firstChild);
+			const lastChildLoc = sourceCode.getLoc(lastChild);
+			const paddingAfterOpeningLines = firstChildLoc.start.line - openingSequence.loc.end.line - 1;
+			const paddingBeforeClosingLines = closingSequence ? closingSequence.loc.start.line - lastChildLoc.end.line - 1 : null;
+			if (padding === "always") {
+				if (paddingAfterOpeningLines <= 0) {
+					const reportEndToken = parsed.info ?? openingSequence;
+					const reportRange = [openingSequence.range[0], reportEndToken.range[1]];
+					context.report({
+						messageId: "expectedPaddingAfterOpeningMarker",
+						loc: getSourceLocationFromRange(sourceCode, node, reportRange),
+						fix(fixer) {
+							return fixer.insertTextAfterRange(reportRange, "\n");
+						}
+					});
+				}
+				if (closingSequence && paddingBeforeClosingLines !== null && paddingBeforeClosingLines <= 0) context.report({
+					messageId: "expectedPaddingBeforeClosingMarker",
+					loc: getSourceLocationFromRange(sourceCode, node, closingSequence.range),
+					fix(fixer) {
+						return fixer.insertTextBeforeRange([closingSequence.range[0] - closingSequence.loc.start.column + 1, closingSequence.range[1]], "\n");
+					}
+				});
+			} else if (padding === "never") {
+				if (paddingAfterOpeningLines > 0) {
+					const firstChildRange = sourceCode.getRange(firstChild);
+					context.report({
+						messageId: "unexpectedPaddingAfterOpeningMarker",
+						loc: getSourceLocationFromRange(sourceCode, node, [openingSequence.range[1], firstChildRange[0]]),
+						*fix(fixer) {
+							const lines = getParsedLines(sourceCode);
+							for (let lineNumber = openingSequence.loc.end.line + 1; lineNumber < firstChildLoc.start.line; lineNumber++) {
+								const line = lines.get(lineNumber);
+								yield fixer.removeRange(line.range);
+							}
+						}
+					});
+				}
+				if (closingSequence && paddingBeforeClosingLines !== null && paddingBeforeClosingLines > 0) {
+					const lastChildRange = sourceCode.getRange(lastChild);
+					context.report({
+						messageId: "unexpectedPaddingBeforeClosingMarker",
+						loc: getSourceLocationFromRange(sourceCode, node, [lastChildRange[1], closingSequence.range[0]]),
+						*fix(fixer) {
+							const lines = getParsedLines(sourceCode);
+							for (let lineNumber = lastChildLoc.end.line + 1; lineNumber < closingSequence.loc.start.line; lineNumber++) {
+								const line = lines.get(lineNumber);
+								yield fixer.removeRange(line.range);
+							}
+						}
+					});
+				}
+			}
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/padding-line-between-blocks.ts
 /**
@@ -10580,397 +10696,157 @@ var table_leading_trailing_pipes_default = createRule("table-leading-trailing-pi
 });
 
 //#endregion
-//#region src/rules/table-pipe-alignment.ts
-var table_pipe_alignment_default = createRule("table-pipe-alignment", {
+//#region src/rules/table-pipe-spacing.ts
+const currentOption = /* @__PURE__ */ new WeakMap();
+/**
+* Get the current options for the given source code.
+* This is a method that allows you to access the configuration of this rule from another rule.
+*/
+function getCurrentTablePipeSpacingOption(sourceCode) {
+	return currentOption.get(sourceCode) ?? null;
+}
+/**
+* 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 alignment of table pipes",
+			description: "enforce consistent spacing around table pipes",
 			categories: ["standard"],
-			listCategory: "Decorative"
+			listCategory: "Whitespace"
 		},
-		fixable: "code",
+		fixable: "whitespace",
 		hasSuggestions: false,
 		schema: [{
 			type: "object",
-			properties: { column: { enum: ["minimum", "consistent"] } },
+			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: {
-			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}})."
+			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 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);
+		const options = parseOptions(context.options[0]);
+		currentOption.set(sourceCode, options);
+		/**
+		* 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 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 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;
 		}
@@ -11201,6 +11077,256 @@ var table_pipe_spacing_default = createRule("table-pipe-spacing", {
 	}
 });
 
+//#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 spacingRuleOptions = getCurrentTablePipeSpacingOption(sourceCode);
+				const needSpaceBeforePipe = spacingRuleOptions ? spacingRuleOptions.trailingSpace === "always" : 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/thematic-break-character-style.ts
 var thematic_break_character_style_default = createRule("thematic-break-character-style", {
@@ -11442,6 +11568,7 @@ const rules$1 = [
 	ordered_list_marker_sequence_default,
 	ordered_list_marker_start_default,
 	ordered_list_marker_style_default,
+	padded_custom_containers_default,
 	padding_line_between_blocks_default,
 	prefer_autolinks_default,
 	prefer_fenced_code_blocks_default,
@@ -11539,6 +11666,7 @@ const rules$2 = {
 	"markdown-preferences/ordered-list-marker-sequence": "error",
 	"markdown-preferences/ordered-list-marker-start": "error",
 	"markdown-preferences/ordered-list-marker-style": "error",
+	"markdown-preferences/padded-custom-containers": "error",
 	"markdown-preferences/padding-line-between-blocks": "error",
 	"markdown-preferences/prefer-autolinks": "error",
 	"markdown-preferences/prefer-fenced-code-blocks": "error",
@@ -11560,7 +11688,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.28.0";
+const version = "0.29.1";
 
 //#endregion
 //#region src/language/extensions/micromark-custom-container.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.28.0",
+  "version": "0.29.1",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -25,7 +25,7 @@
     "markdownlint": "npx -y markdownlint-cli2 .",
     "test": "npm run mocha -- \"tests/src/**/*.ts\" --reporter=dot --timeout=60000",
     "test:debug": "node --experimental-strip-types --experimental-transform-types ./node_modules/mocha/bin/mocha.js \"tests/src/**/*.ts\" --reporter=dot --timeout=60000",
-    "cover": "c8 --reporter=lcov npm run test",
+    "cover": "c8 --reporter=lcov --reporter=text npm run test:debug",
     "test:update": "npm run mocha -- \"tests/src/**/*.ts\" --reporter=dot --update",
     "update": "npm run ts -- ./tools/update.ts && npm run eslint-fix",
     "update:resources": "npm run ts -- ./tools/update-resources.ts && npm run eslint-fix",