eslint-plugin-markdown-preferences 0.29.0 → 0.30.0

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-->
@@ -192,21 +190,23 @@ The rules with the following 💄 are included in the `standard` config.
 
 <!-- prettier-ignore-start -->
 
-| Rule ID                                                                                                                                                   | Description                                                          | Fixable | Config |
-| :-------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------- | :-----: | :----: |
-| [markdown-preferences/blockquote-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/blockquote-marker-alignment.html) | enforce consistent alignment of blockquote markers                   |   🔧    |  ⭐💄  |
-| [markdown-preferences/indent](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/indent.html)                                           | enforce consistent indentation in Markdown files                     |   🔧    |   💄   |
-| [markdown-preferences/link-bracket-newline](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-bracket-newline.html)               | enforce linebreaks after opening and before closing link brackets    |   🔧    |   💄   |
-| [markdown-preferences/link-bracket-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-bracket-spacing.html)               | enforce consistent spacing inside link brackets                      |   🔧    |   💄   |
-| [markdown-preferences/link-paren-newline](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-newline.html)                   | enforce linebreaks after opening and before closing link parentheses |   🔧    |   💄   |
-| [markdown-preferences/link-paren-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-spacing.html)                   | enforce consistent spacing inside link parentheses                   |   🔧    |   💄   |
-| [markdown-preferences/list-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/list-marker-alignment.html)             | enforce consistent alignment of list markers                         |   🔧    |  ⭐💄  |
-| [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                        |   🔧    |   💄   |
+| Rule ID                                                                                                                                                           | Description                                                                    | Fixable | Config |
+| :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------- | :-----: | :----: |
+| [markdown-preferences/blockquote-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/blockquote-marker-alignment.html)         | enforce consistent alignment of blockquote markers                             |   🔧    |  ⭐💄  |
+| [markdown-preferences/code-fence-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-spacing.html)                           | require or disallow spacing between opening code fence and language identifier |   🔧    |        |
+| [markdown-preferences/custom-container-marker-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/custom-container-marker-spacing.html) | require or disallow spacing between opening custom container marker and info   |   🔧    |        |
+| [markdown-preferences/indent](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/indent.html)                                                   | enforce consistent indentation in Markdown files                               |   🔧    |   💄   |
+| [markdown-preferences/link-bracket-newline](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-bracket-newline.html)                       | enforce linebreaks after opening and before closing link brackets              |   🔧    |   💄   |
+| [markdown-preferences/link-bracket-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-bracket-spacing.html)                       | enforce consistent spacing inside link brackets                                |   🔧    |   💄   |
+| [markdown-preferences/link-paren-newline](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-newline.html)                           | enforce linebreaks after opening and before closing link parentheses           |   🔧    |   💄   |
+| [markdown-preferences/link-paren-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-spacing.html)                           | enforce consistent spacing inside link parentheses                             |   🔧    |   💄   |
+| [markdown-preferences/list-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/list-marker-alignment.html)                     | enforce consistent alignment of list markers                                   |   🔧    |  ⭐💄  |
+| [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                                  |   🔧    |   💄   |
 
 <!-- prettier-ignore-end -->
 

package/lib/index.d.ts

@@ -45,11 +45,21 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-length.html
    */
   'markdown-preferences/code-fence-length'?: Linter.RuleEntry<MarkdownPreferencesCodeFenceLength>;
+  /**
+   * require or disallow spacing between opening code fence and language identifier
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-spacing.html
+   */
+  'markdown-preferences/code-fence-spacing'?: Linter.RuleEntry<MarkdownPreferencesCodeFenceSpacing>;
   /**
    * enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html
    */
   'markdown-preferences/code-fence-style'?: Linter.RuleEntry<MarkdownPreferencesCodeFenceStyle>;
+  /**
+   * require or disallow spacing between opening custom container marker and info
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/custom-container-marker-spacing.html
+   */
+  'markdown-preferences/custom-container-marker-spacing'?: Linter.RuleEntry<MarkdownPreferencesCustomContainerMarkerSpacing>;
   /**
    * require link definitions and footnote definitions to be placed at the end of the document
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html
@@ -287,9 +297,15 @@ type MarkdownPreferencesCodeFenceLength = [] | [{
     fallbackLength?: (number | ("minimum" | "as-is"));
   }[];
 }];
+type MarkdownPreferencesCodeFenceSpacing = [] | [{
+  space?: ("always" | "never");
+}];
 type MarkdownPreferencesCodeFenceStyle = [] | [{
   style?: ("backtick" | "tilde");
 }];
+type MarkdownPreferencesCustomContainerMarkerSpacing = [] | [{
+  space?: ("always" | "never");
+}];
 type MarkdownPreferencesDefinitionsLast = [] | [{
   linkDefinitionPlacement?: {
     referencedFromSingleSection?: ("document-last" | "section-last");
@@ -516,7 +532,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.29.0";
+declare const version: "0.30.0";
 //#endregion
 //#region src/language/ast-types.d.ts
 type Node = mdast.Node;

package/lib/index.js

@@ -1279,6 +1279,62 @@ var code_fence_length_default = createRule("code-fence-length", {
 	}
 });
 
+//#endregion
+//#region src/rules/code-fence-spacing.ts
+var code_fence_spacing_default = createRule("code-fence-spacing", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "require or disallow spacing between opening code fence and language identifier",
+			categories: [],
+			listCategory: "Whitespace"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { space: { enum: ["always", "never"] } },
+			additionalProperties: false
+		}],
+		messages: {
+			expectedSpace: "Expected a space between code fence and language identifier.",
+			unexpectedSpace: "Unexpected space between code fence and language identifier."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const space = (context.options[0] || {}).space || "never";
+		return { code(node) {
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed) return;
+			const { openingFence, language: language$2 } = parsed;
+			if (!language$2) return;
+			const hasSpace = openingFence.range[1] < language$2.range[0];
+			if (space === "always") {
+				if (hasSpace) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, language$2.range),
+					messageId: "expectedSpace",
+					fix(fixer) {
+						return fixer.insertTextAfterRange(openingFence.range, " ");
+					}
+				});
+			} else if (space === "never") {
+				if (!hasSpace) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingFence.range[1], language$2.range[0]]),
+					messageId: "unexpectedSpace",
+					fix(fixer) {
+						return fixer.removeRange([openingFence.range[1], language$2.range[0]]);
+					}
+				});
+			}
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/code-fence-style.ts
 var code_fence_style_default = createRule("code-fence-style", {
@@ -1327,6 +1383,127 @@ var code_fence_style_default = createRule("code-fence-style", {
 	}
 });
 
+//#endregion
+//#region src/utils/custom-container.ts
+const RE_OPENING_SEQUENCE = /^(:{3,})/u;
+/**
+* Parse the custom container.
+*/
+function parseCustomContainer(sourceCode, node) {
+	const loc = sourceCode.getLoc(node);
+	const range = sourceCode.getRange(node);
+	const text = sourceCode.text.slice(...range);
+	const match = RE_OPENING_SEQUENCE.exec(text);
+	if (!match) return null;
+	const [, sequenceText] = match;
+	const afterOpeningSequence = sourceCode.lines[loc.start.line - 1].slice(loc.start.column - 1 + sequenceText.length);
+	const trimmedAfterOpeningSequence = afterOpeningSequence.trimStart();
+	const spaceAfterOpeningSequenceLength = afterOpeningSequence.length - trimmedAfterOpeningSequence.length;
+	const infoText = trimmedAfterOpeningSequence.trimEnd();
+	if (!infoText) return null;
+	const openingSequenceRange = [range[0], range[0] + sequenceText.length];
+	const openingSequence = {
+		text: sequenceText,
+		range: openingSequenceRange,
+		loc: getSourceLocationFromRange(sourceCode, node, openingSequenceRange)
+	};
+	const infoRange = [openingSequence.range[1] + spaceAfterOpeningSequenceLength, openingSequence.range[1] + spaceAfterOpeningSequenceLength + infoText.length];
+	const info = {
+		text: infoText,
+		range: infoRange,
+		loc: getSourceLocationFromRange(sourceCode, node, infoRange)
+	};
+	const sequenceChar = sequenceText[0];
+	let closingSequenceText = "";
+	const trimmed = text.trimEnd();
+	const trailingSpacesLength = text.length - trimmed.length;
+	for (let index = trimmed.length - 1; index >= 0; index--) {
+		const c = trimmed[index];
+		if (c === sequenceChar || isSpaceOrTab(c)) {
+			closingSequenceText = c + closingSequenceText;
+			continue;
+		}
+		if (c === ">") {
+			closingSequenceText = ` ${closingSequenceText}`;
+			continue;
+		}
+		if (c === "\n") break;
+		closingSequenceText = "";
+		break;
+	}
+	closingSequenceText = closingSequenceText.trimStart();
+	if (!closingSequenceText || !closingSequenceText.startsWith(sequenceText)) return {
+		openingSequence,
+		info,
+		closingSequence: null
+	};
+	const closingSequenceRange = [range[1] - trailingSpacesLength - closingSequenceText.length, range[1] - trailingSpacesLength];
+	return {
+		openingSequence,
+		info,
+		closingSequence: {
+			text: closingSequenceText,
+			range: closingSequenceRange,
+			loc: getSourceLocationFromRange(sourceCode, node, closingSequenceRange)
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/custom-container-marker-spacing.ts
+var custom_container_marker_spacing_default = createRule("custom-container-marker-spacing", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "require or disallow spacing between opening custom container marker and info",
+			categories: [],
+			listCategory: "Whitespace"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { space: { enum: ["always", "never"] } },
+			additionalProperties: false
+		}],
+		messages: {
+			expectedSpace: "Expected a space between opening custom container marker and info.",
+			unexpectedSpace: "Unexpected space between opening custom container marker and info."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const space = (context.options[0] || {}).space || "always";
+		return { customContainer(node) {
+			const parsed = parseCustomContainer(sourceCode, node);
+			if (!parsed) return;
+			const { openingSequence, info } = parsed;
+			const hasSpace = openingSequence.range[1] < info.range[0];
+			if (space === "always") {
+				if (hasSpace) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, info.range),
+					messageId: "expectedSpace",
+					fix(fixer) {
+						return fixer.insertTextAfterRange(openingSequence.range, " ");
+					}
+				});
+			} else if (space === "never") {
+				if (!hasSpace) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingSequence.range[1], info.range[0]]),
+					messageId: "unexpectedSpace",
+					fix(fixer) {
+						return fixer.removeRange([openingSequence.range[1], info.range[0]]);
+					}
+				});
+			}
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/definitions-last.ts
 /**
@@ -7545,72 +7722,6 @@ var list_marker_alignment_default = createRule("list-marker-alignment", {
 	}
 });
 
-//#endregion
-//#region src/utils/custom-container.ts
-const RE_OPENING_SEQUENCE = /^(:{3,})/u;
-/**
-* Parse the custom container.
-*/
-function parseCustomContainer(sourceCode, node) {
-	const loc = sourceCode.getLoc(node);
-	const range = sourceCode.getRange(node);
-	const text = sourceCode.text.slice(...range);
-	const match = RE_OPENING_SEQUENCE.exec(text);
-	if (!match) return null;
-	const [, sequenceText] = match;
-	const afterOpeningSequence = sourceCode.lines[loc.start.line - 1].slice(loc.start.column - 1 + sequenceText.length);
-	const trimmedAfterOpeningSequence = afterOpeningSequence.trimStart();
-	const spaceAfterOpeningSequenceLength = afterOpeningSequence.length - trimmedAfterOpeningSequence.length;
-	const infoText = trimmedAfterOpeningSequence.trimEnd();
-	if (!infoText) return null;
-	const openingSequenceRange = [range[0], range[0] + sequenceText.length];
-	const openingSequence = {
-		text: sequenceText,
-		range: openingSequenceRange,
-		loc: getSourceLocationFromRange(sourceCode, node, openingSequenceRange)
-	};
-	const infoRange = [openingSequence.range[1] + spaceAfterOpeningSequenceLength, openingSequence.range[1] + spaceAfterOpeningSequenceLength + infoText.length];
-	const info = {
-		text: infoText,
-		range: infoRange,
-		loc: getSourceLocationFromRange(sourceCode, node, infoRange)
-	};
-	const sequenceChar = sequenceText[0];
-	let closingSequenceText = "";
-	const trimmed = text.trimEnd();
-	const trailingSpacesLength = text.length - trimmed.length;
-	for (let index = trimmed.length - 1; index >= 0; index--) {
-		const c = trimmed[index];
-		if (c === sequenceChar || isSpaceOrTab(c)) {
-			closingSequenceText = c + closingSequenceText;
-			continue;
-		}
-		if (c === ">") {
-			closingSequenceText = ` ${closingSequenceText}`;
-			continue;
-		}
-		if (c === "\n") break;
-		closingSequenceText = "";
-		break;
-	}
-	closingSequenceText = closingSequenceText.trimStart();
-	if (!closingSequenceText || !closingSequenceText.startsWith(sequenceText)) return {
-		openingSequence,
-		info,
-		closingSequence: null
-	};
-	const closingSequenceRange = [range[1] - trailingSpacesLength - closingSequenceText.length, range[1] - trailingSpacesLength];
-	return {
-		openingSequence,
-		info,
-		closingSequence: {
-			text: closingSequenceText,
-			range: closingSequenceRange,
-			loc: getSourceLocationFromRange(sourceCode, node, closingSequenceRange)
-		}
-	};
-}
-
 //#endregion
 //#region src/rules/no-implicit-block-closing.ts
 var no_implicit_block_closing_default = createRule("no-implicit-block-closing", {
@@ -10696,302 +10807,61 @@ 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",
-			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",
+			description: "enforce consistent spacing around table pipes",
 			categories: ["standard"],
 			listCategory: "Whitespace"
 		},
@@ -11060,6 +10930,7 @@ var table_pipe_spacing_default = createRule("table-pipe-spacing", {
 	create(context) {
 		const sourceCode = context.sourceCode;
 		const options = parseOptions(context.options[0]);
+		currentOption.set(sourceCode, options);
 		/**
 		* Verify for the leading pipe.
 		*/
@@ -11317,6 +11188,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", {
@@ -11533,7 +11654,9 @@ const rules$1 = [
 	bullet_list_marker_style_default,
 	canonical_code_block_language_default,
 	code_fence_length_default,
+	code_fence_spacing_default,
 	code_fence_style_default,
+	custom_container_marker_spacing_default,
 	definitions_last_default,
 	emoji_notation_default,
 	emphasis_delimiters_style_default,
@@ -11678,7 +11801,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.29.0";
+const version = "0.30.0";
 
 //#endregion
 //#region src/language/extensions/micromark-custom-container.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "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",