eslint-plugin-markdown-preferences 0.29.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-->

package/lib/index.d.ts

@@ -516,7 +516,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.29.1";
 //#endregion
 //#region src/language/ast-types.d.ts
 type Node = mdast.Node;

package/lib/index.js

@@ -10696,257 +10696,16 @@ 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", {
-	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));
-		} };
-	}
-});
+//#region src/rules/table-pipe-spacing.ts
+const currentOption = /* @__PURE__ */ new WeakMap();
 /**
-* Convert a parsed table row to row data
+* 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 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
-		};
-	}) };
+function getCurrentTablePipeSpacingOption(sourceCode) {
+	return currentOption.get(sourceCode) ?? null;
 }
 /**
-* 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) {
@@ -11060,6 +10819,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 +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", {
@@ -11678,7 +11688,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.29.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.29.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",