eslint-plugin-markdown-preferences 0.26.1 → 0.28.0

package/lib/index.js

@@ -3,6 +3,16 @@ import stringWidth from "string-width";
 import emojiRegex from "emoji-regex-xs";
 import path from "node:path";
 import markdown from "@eslint/markdown";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { frontmatter } from "micromark-extension-frontmatter";
+import { gfm } from "micromark-extension-gfm";
+import { math } from "micromark-extension-math";
+import { mathFromMarkdown } from "mdast-util-math";
+import { markdownLineEnding, markdownSpace } from "micromark-util-character";
+import { codes, constants, types } from "micromark-util-symbol";
+import { factorySpace } from "micromark-factory-space";
 
 //#region src/utils/index.ts
 /**
@@ -957,14 +967,14 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 				if (node.ordered) return;
 				checkBulletList(node);
 			},
-			"root, blockquote, listItem, footnoteDefinition"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				containerStack = {
 					node,
 					level: node.type === "listItem" ? containerStack.level + 1 : 1,
 					upper: containerStack
 				};
 			},
-			"root, blockquote, listItem, footnoteDefinition:exit"() {
+			"root, blockquote, listItem, footnoteDefinition, customContainer:exit"() {
 				containerStack = containerStack.upper;
 			}
 		};
@@ -979,28 +989,14 @@ const RE_LANGUAGE = /^(\w*)/u;
 * Parse the fenced code block.
 */
 function parseFencedCodeBlock(sourceCode, node) {
+	if (getCodeBlockKind(sourceCode, node) === "indented") return null;
 	const loc = sourceCode.getLoc(node);
 	const range = sourceCode.getRange(node);
 	const text = sourceCode.text.slice(...range);
 	const match = RE_OPENING_FENCE.exec(text);
 	if (!match) return null;
 	const [, fenceText] = match;
-	const fenceChar = fenceText[0];
-	let closingFenceText = "";
-	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 === fenceChar || isSpaceOrTab(c)) {
-			closingFenceText = c + closingFenceText;
-			continue;
-		}
-		if (c === "\n") break;
-		return null;
-	}
-	closingFenceText = closingFenceText.trimStart();
-	if (!closingFenceText || !closingFenceText.startsWith(fenceText)) return null;
-	const afterOpeningFence = getParsedLines(sourceCode).get(loc.start.line).text.slice(fenceText.length);
+	const afterOpeningFence = sourceCode.lines[loc.start.line - 1].slice(loc.start.column - 1 + fenceText.length);
 	const trimmedAfterOpeningFence = afterOpeningFence.trimStart();
 	const spaceAfterOpeningFenceLength = afterOpeningFence.length - trimmedAfterOpeningFence.length;
 	let languageText = "";
@@ -1009,45 +1005,49 @@ function parseFencedCodeBlock(sourceCode, node) {
 	const trimmedAfterLanguage = afterLanguage.trimStart();
 	const spaceAfterLanguageLength = afterLanguage.length - trimmedAfterLanguage.length;
 	const metaText = trimmedAfterLanguage.trimEnd();
+	const openingFenceRange = [range[0], range[0] + fenceText.length];
 	const openingFence = {
 		text: fenceText,
-		range: [range[0], range[0] + fenceText.length],
-		loc: {
-			start: loc.start,
-			end: {
-				line: loc.start.line,
-				column: loc.start.column + fenceText.length
-			}
-		}
+		range: openingFenceRange,
+		loc: getSourceLocationFromRange(sourceCode, node, openingFenceRange)
 	};
-	const language$2 = languageText ? {
+	const languageRange = languageText ? [openingFence.range[1] + spaceAfterOpeningFenceLength, openingFence.range[1] + spaceAfterOpeningFenceLength + languageText.length] : null;
+	const language$2 = languageText && languageRange ? {
 		text: languageText,
-		range: [openingFence.range[1] + spaceAfterOpeningFenceLength, openingFence.range[1] + spaceAfterOpeningFenceLength + languageText.length],
-		loc: {
-			start: {
-				line: openingFence.loc.end.line,
-				column: openingFence.loc.end.column + spaceAfterOpeningFenceLength
-			},
-			end: {
-				line: openingFence.loc.end.line,
-				column: openingFence.loc.end.column + spaceAfterOpeningFenceLength + languageText.length
-			}
-		}
+		range: languageRange,
+		loc: getSourceLocationFromRange(sourceCode, node, languageRange)
 	} : null;
-	const meta = language$2 && metaText ? {
+	const metaRange = language$2 && metaText ? [language$2.range[1] + spaceAfterLanguageLength, language$2.range[1] + spaceAfterLanguageLength + metaText.length] : null;
+	const meta = language$2 && metaText && metaRange ? {
 		text: metaText,
-		range: [language$2.range[1] + spaceAfterLanguageLength, language$2.range[1] + spaceAfterLanguageLength + metaText.length],
-		loc: {
-			start: {
-				line: language$2.loc.end.line,
-				column: language$2.loc.end.column + spaceAfterLanguageLength
-			},
-			end: {
-				line: language$2.loc.end.line,
-				column: language$2.loc.end.column + spaceAfterLanguageLength + metaText.length
-			}
-		}
+		range: metaRange,
+		loc: getSourceLocationFromRange(sourceCode, node, metaRange)
 	} : null;
+	const fenceChar = fenceText[0];
+	let closingFenceText = "";
+	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 === fenceChar || isSpaceOrTab(c)) {
+			closingFenceText = c + closingFenceText;
+			continue;
+		}
+		if (c === ">") {
+			closingFenceText = ` ${closingFenceText}`;
+			continue;
+		}
+		if (c === "\n") break;
+		closingFenceText = "";
+		break;
+	}
+	closingFenceText = closingFenceText.trimStart();
+	if (!closingFenceText || !closingFenceText.startsWith(fenceText)) return {
+		openingFence,
+		language: language$2,
+		meta,
+		closingFence: null
+	};
 	return {
 		openingFence,
 		language: language$2,
@@ -1117,10 +1117,10 @@ var canonical_code_block_language_default = createRule("canonical-code-block-lan
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const languages = context.options[0]?.languages || DEFAULT_LANGUAGES;
+		const languages$1 = context.options[0]?.languages || DEFAULT_LANGUAGES;
 		return { code(node) {
-			if (!node.lang || !languages[node.lang]) return;
-			const canonical = languages[node.lang];
+			if (!node.lang || !languages$1[node.lang]) return;
+			const canonical = languages$1[node.lang];
 			const current = node.lang;
 			if (current === canonical) return;
 			const parsed = parseFencedCodeBlock(sourceCode, node);
@@ -1217,8 +1217,9 @@ var code_fence_length_default = createRule("code-fence-length", {
 					actual: parsed.openingFence.text
 				},
 				messageId: "notPreferred",
-				fix(fixer) {
-					return [fixer.replaceTextRange(parsed.openingFence.range, expectedFence), fixer.replaceTextRange(parsed.closingFence.range, expectedFence)];
+				*fix(fixer) {
+					yield fixer.replaceTextRange(parsed.openingFence.range, expectedFence);
+					if (parsed.closingFence) yield fixer.replaceTextRange(parsed.closingFence.range, expectedFence);
 				}
 			});
 		}
@@ -1257,14 +1258,14 @@ var code_fence_length_default = createRule("code-fence-length", {
 		/**
 		* Verify that the opening and closing fence lengths match.
 		*/
-		function verifyClosingFenceLength(node, parsed) {
-			if (parsed.openingFence.text.length === parsed.closingFence.text.length) return true;
+		function verifyClosingFenceLength(node, { openingFence, closingFence }) {
+			if (!closingFence || openingFence.text.length === closingFence.text.length) return true;
 			context.report({
 				node,
-				loc: parsed.closingFence.loc,
+				loc: closingFence.loc,
 				messageId: "notMatch",
 				fix(fixer) {
-					return [fixer.replaceTextRange(parsed.closingFence.range, parsed.openingFence.text)];
+					return [fixer.replaceTextRange(closingFence.range, openingFence.text)];
 				}
 			});
 			return false;
@@ -1317,8 +1318,9 @@ var code_fence_style_default = createRule("code-fence-style", {
 					actual: parsed.openingFence.text
 				},
 				messageId: "useCodeFenceStyle",
-				fix(fixer) {
-					return [fixer.replaceTextRange(parsed.openingFence.range, expectedOpeningFence), fixer.replaceTextRange(parsed.closingFence.range, expectedChar.repeat(Math.max(3, parsed.closingFence.text.length)))];
+				*fix(fixer) {
+					yield fixer.replaceTextRange(parsed.openingFence.range, expectedOpeningFence);
+					if (parsed.closingFence) yield fixer.replaceTextRange(parsed.closingFence.range, expectedChar.repeat(Math.max(3, parsed.closingFence.text.length)));
 				}
 			});
 		} };
@@ -5296,6 +5298,120 @@ function parseListItem(sourceCode, node) {
 	};
 }
 
+//#endregion
+//#region src/utils/math-block.ts
+/**
+* Parse the math block.
+*/
+function parseMathBlock(sourceCode, node) {
+	const range = sourceCode.getRange(node);
+	const text = sourceCode.text.slice(...range);
+	const parsedOpening = parseMathOpeningSequenceFromText(text);
+	if (parsedOpening === null) return null;
+	const openingSequenceRange = [range[0], range[0] + parsedOpening.openingSequence.length];
+	const openingSequence = {
+		text: parsedOpening.openingSequence,
+		range: openingSequenceRange,
+		loc: getSourceLocationFromRange(sourceCode, node, openingSequenceRange)
+	};
+	const parsedClosing = parseMathClosingSequenceFromText(text);
+	if (parsedClosing == null || parsedClosing.closingSequence !== parsedOpening.openingSequence) {
+		const contentRange$1 = [openingSequence.range[1] + parsedOpening.after.length, range[1]];
+		return {
+			openingSequence,
+			content: {
+				text: text.slice(parsedOpening.after.length),
+				range: contentRange$1,
+				loc: getSourceLocationFromRange(sourceCode, node, contentRange$1)
+			},
+			closingSequence: null,
+			after: null
+		};
+	}
+	const spaceAfterClosingRange = [range[1] - parsedClosing.after.length, range[1]];
+	const spaceAfterClosing = {
+		text: parsedClosing.after,
+		range: spaceAfterClosingRange,
+		loc: getSourceLocationFromRange(sourceCode, node, spaceAfterClosingRange)
+	};
+	const closingSequenceRange = [spaceAfterClosing.range[0] - parsedClosing.closingSequence.length, spaceAfterClosing.range[0]];
+	const closingSequence = {
+		text: parsedClosing.closingSequence,
+		range: closingSequenceRange,
+		loc: getSourceLocationFromRange(sourceCode, node, closingSequenceRange)
+	};
+	const contentRange = [openingSequence.range[1] + parsedOpening.after.length, closingSequence.range[0] - parsedClosing.before.length];
+	const contentText = sourceCode.text.slice(...contentRange);
+	return {
+		openingSequence,
+		content: {
+			text: contentText,
+			range: contentRange,
+			loc: getSourceLocationFromRange(sourceCode, node, contentRange)
+		},
+		closingSequence,
+		after: spaceAfterClosing.range[0] < spaceAfterClosing.range[1] ? spaceAfterClosing : null
+	};
+}
+/**
+* Parse the opening sequence from a text string.
+*/
+function parseMathOpeningSequenceFromText(text) {
+	if (!text.startsWith("$")) return null;
+	let openingSequenceAfterOffset = 1;
+	while (openingSequenceAfterOffset < text.length && text[openingSequenceAfterOffset] === "$") openingSequenceAfterOffset++;
+	const afterOffset = skipWhitespace(openingSequenceAfterOffset);
+	if (afterOffset === openingSequenceAfterOffset || afterOffset >= text.length) return null;
+	return {
+		openingSequence: text.slice(0, openingSequenceAfterOffset),
+		after: text.slice(openingSequenceAfterOffset, afterOffset)
+	};
+	/**
+	* Skip whitespace characters at the start of the text.
+	*/
+	function skipWhitespace(index) {
+		let inIndent = false;
+		let result = index;
+		let c;
+		while (result < text.length && (c = text[result]) && (isWhitespace(c) || inIndent && c === ">")) {
+			result++;
+			if (c === "\n") inIndent = true;
+			else if (inIndent) inIndent = isWhitespace(c) || c === ">";
+		}
+		return result;
+	}
+}
+/**
+* Parse the closing sequence from a text string.
+*/
+function parseMathClosingSequenceFromText(text) {
+	const trimmedEndOffset = skipEndWhitespace(text.length - 1) + 1;
+	if (trimmedEndOffset <= 0 || text[trimmedEndOffset - 1] !== "$") return null;
+	let closingSequenceBeforeOffset = trimmedEndOffset - 2;
+	while (closingSequenceBeforeOffset >= 0 && text[closingSequenceBeforeOffset] === "$") closingSequenceBeforeOffset--;
+	const beforeOffset = skipEndWhitespace(closingSequenceBeforeOffset);
+	if (beforeOffset === closingSequenceBeforeOffset || beforeOffset < 0) return null;
+	return {
+		before: text.slice(beforeOffset + 1, closingSequenceBeforeOffset + 1),
+		closingSequence: text.slice(closingSequenceBeforeOffset + 1, trimmedEndOffset),
+		after: text.slice(trimmedEndOffset)
+	};
+	/**
+	* Skip whitespace characters at the end of the text.
+	*/
+	function skipEndWhitespace(index) {
+		let result = index;
+		let c;
+		while (result >= 0 && (c = text[result]) && isWhitespace(c)) result--;
+		if (c === ">") {
+			let index2 = result - 1;
+			while (index2 >= 0 && (c = text[index2]) && (isSpaceOrTab(c) || c === ">")) index2--;
+			if (c === "\n") return skipEndWhitespace(index2);
+		}
+		return result;
+	}
+}
+
 //#endregion
 //#region src/rules/indent.ts
 /**
@@ -5575,7 +5691,10 @@ var indent_default = createRule("indent", {
 			definition: verifyLinkDefinition,
 			table: verifyTable,
 			list: verifyList,
-			inlineCode: verifyInlineCode,
+			customContainer: verifyCustomContainer,
+			math: verifyMathBlock,
+			importCodeSnippet: verifyImportCodeSnippet,
+			inlineCode: verifyInlineCodeOrInlineMath,
 			emphasis: verifyEmphasisOrStrongOrDelete,
 			strong: verifyEmphasisOrStrongOrDelete,
 			delete: verifyEmphasisOrStrongOrDelete,
@@ -5584,6 +5703,7 @@ var indent_default = createRule("indent", {
 			footnoteReference: verifyInline,
 			break: verifyInline,
 			text: verifyText,
+			inlineMath: verifyInlineCodeOrInlineMath,
 			blockquote(node) {
 				verifyBlockquote(node);
 				blockStack = new BlockquoteStack(node);
@@ -5640,32 +5760,9 @@ var indent_default = createRule("indent", {
 			verifyLinesIndent([loc.start.line, loc.end.line], (lineNumber) => blockStack.getExpectedIndent({
 				lineNumber,
 				block: true
-			}), additionalFixes);
-			/**
-			* Additional fixes for code block content lines.
-			*/
-			function* additionalFixes(fixer, info) {
-				if (info.loc.start.line !== loc.start.line) return;
-				for (let lineNumber = loc.start.line + 1; lineNumber < loc.end.line; lineNumber++) {
-					const line = getParsedLines(sourceCode).get(lineNumber);
-					if (!line) continue;
-					if (info.expectedIndentWidth > info.actualIndentWidth) {
-						const before = sliceWidth(line.text, 0, info.actualIndentWidth);
-						const after = sliceWidth(line.text, info.actualIndentWidth);
-						const diffWidth = info.expectedIndentWidth - info.actualIndentWidth;
-						yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + " ".repeat(diffWidth) + after);
-					} else {
-						let before = sliceWidth(line.text, 0, info.expectedIndentWidth);
-						let between = sliceWidth(line.text, info.expectedIndentWidth, info.actualIndentWidth);
-						const after = sliceWidth(line.text, info.actualIndentWidth);
-						while (between && !isSpaceOrTab(between)) {
-							before += between[0];
-							between = between.slice(1);
-						}
-						yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + after);
-					}
-				}
-			}
+			}), (fixer, info) => {
+				return additionalFixesForCodeBlock(node, fixer, info, loc.start.line + 1, loc.end.line - 1);
+			});
 		}
 		/**
 		* Verify an HTML node.
@@ -5782,6 +5879,41 @@ var indent_default = createRule("indent", {
 			}
 		}
 		/**
+		* Verify a custom container node.
+		*/
+		function verifyCustomContainer(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent([loc.start.line, loc.end.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify a math node.
+		*/
+		function verifyMathBlock(node) {
+			const parsed = parseMathBlock(sourceCode, node);
+			if (!parsed) return;
+			const loc = sourceCode.getLoc(node);
+			const endLineToBeChecked = parsed.closingSequence && inlineToBeChecked(parsed.closingSequence.loc.start);
+			verifyLinesIndent(endLineToBeChecked ? [loc.start.line, loc.end.line] : [loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}), (fixer, info) => {
+				return additionalFixesForCodeBlock(node, fixer, info, loc.start.line + 1, endLineToBeChecked ? loc.end.line - 1 : loc.end.line);
+			});
+		}
+		/**
+		* Verify an import code snippet node.
+		*/
+		function verifyImportCodeSnippet(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
 		* Verify a footnote definition node.
 		*/
 		function verifyFootnoteDefinition(node) {
@@ -5792,9 +5924,9 @@ var indent_default = createRule("indent", {
 			}));
 		}
 		/**
-		* Verify an inline code node.
+		* Verify an inline code/math node.
 		*/
-		function verifyInlineCode(node) {
+		function verifyInlineCodeOrInlineMath(node) {
 			const loc = sourceCode.getLoc(node);
 			if (!inlineToBeChecked(loc.start)) return;
 			verifyLinesIndent([loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
@@ -6176,6 +6308,32 @@ var indent_default = createRule("indent", {
 				actualIndentWidth
 			};
 		}
+		/**
+		* Additional fixes for code/math block content lines.
+		*/
+		function* additionalFixesForCodeBlock(node, fixer, info, fixStartLine, fixEndLine) {
+			const loc = sourceCode.getLoc(node);
+			if (info.loc.start.line !== loc.start.line) return;
+			for (let lineNumber = fixStartLine; lineNumber <= fixEndLine; lineNumber++) {
+				const line = getParsedLines(sourceCode).get(lineNumber);
+				if (!line) continue;
+				if (info.expectedIndentWidth > info.actualIndentWidth) {
+					const before = sliceWidth(line.text, 0, info.actualIndentWidth);
+					const after = sliceWidth(line.text, info.actualIndentWidth);
+					const diffWidth = info.expectedIndentWidth - info.actualIndentWidth;
+					yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + " ".repeat(diffWidth) + after);
+				} else {
+					let before = sliceWidth(line.text, 0, info.expectedIndentWidth);
+					let between = sliceWidth(line.text, info.expectedIndentWidth, info.actualIndentWidth);
+					const after = sliceWidth(line.text, info.actualIndentWidth);
+					while (between && !isSpaceOrTab(between)) {
+						before += between[0];
+						between = between.slice(1);
+					}
+					yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + after);
+				}
+			}
+		}
 	}
 });
 
@@ -7387,6 +7545,143 @@ 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", {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "disallow implicit block closing for fenced code blocks, math blocks, and custom blocks",
+			categories: ["recommended", "standard"],
+			listCategory: "Notation"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [],
+		messages: {
+			missingClosingFence: "Missing closing fence for fenced code block.",
+			missingClosingMath: "Missing closing sequence for math block.",
+			missingClosingContainer: "Missing closing sequence for custom container."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return {
+			code(node) {
+				const parsed = parseFencedCodeBlock(sourceCode, node);
+				if (!parsed) return;
+				if (!parsed.closingFence) context.report({
+					node,
+					loc: parsed.openingFence.loc,
+					messageId: "missingClosingFence",
+					fix(fixer) {
+						const openingLoc = parsed.openingFence.loc;
+						const prefix = sourceCode.lines[openingLoc.start.line - 1].slice(0, openingLoc.start.column - 1).replace(/[^\s>]/gu, " ");
+						const closingFence = parsed.openingFence.text;
+						return fixer.insertTextAfter(node, `\n${prefix}${closingFence}`);
+					}
+				});
+			},
+			math(node) {
+				const parsed = parseMathBlock(sourceCode, node);
+				if (!parsed) return;
+				if (!parsed.closingSequence) context.report({
+					node,
+					loc: parsed.openingSequence.loc,
+					messageId: "missingClosingMath",
+					fix(fixer) {
+						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;
+						return fixer.insertTextAfter(node, `\n${prefix}${closingSequence}`);
+					}
+				});
+			},
+			customContainer(node) {
+				const parsed = parseCustomContainer(sourceCode, node);
+				if (!parsed) return;
+				if (!parsed.closingSequence) context.report({
+					node,
+					loc: parsed.openingSequence.loc,
+					messageId: "missingClosingContainer",
+					fix(fixer) {
+						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;
+						return fixer.insertTextAfter(node, `\n${prefix}${closingSequence}`);
+					}
+				});
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/no-laziness-blockquotes.ts
 var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
@@ -7700,31 +7995,37 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 		const sourceCode = context.sourceCode;
 		let codeText = sourceCode.text;
 		return {
+			customContainer: verifyCustomContainer,
+			code: verifyCodeBlock,
 			definition: verifyLinkDefinition,
 			footnoteDefinition: verifyFootnoteDefinition,
 			heading: verifyHeading,
 			image: verifyImage,
 			imageReference: verifyImageReference,
+			inlineMath: verifyInlineMath,
 			link: verifyLink,
 			linkReference: verifyLinkReference,
 			listItem: verifyListItem,
-			blockquote: processBlockquote,
+			table: verifyTable,
 			text: verifyText,
-			table: verifyTable
+			math: verifyMathBlock,
+			blockquote: processBlockquote
 		};
 		/**
-		* Verify a text node.
+		* Verify a code block node.
 		*/
-		function verifyText(node) {
-			verifyTextInNode(node);
+		function verifyCustomContainer(node) {
+			const parsed = parseCustomContainer(sourceCode, node);
+			if (!parsed) return;
+			verifyTextInRange(node, [parsed.openingSequence.range[0], parsed.info.range[1]]);
 		}
 		/**
-		* Verify a table node.
+		* Verify a code block node.
 		*/
-		function verifyTable(node) {
-			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
-			if (!parsedDelimiterRow) return;
-			verifyTextInRange(node, parsedDelimiterRow.range);
+		function verifyCodeBlock(node) {
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed) return;
+			verifyTextInRange(node, [parsed.openingFence.range[0], (parsed.meta ?? parsed.language ?? parsed.openingFence).range[1]]);
 		}
 		/**
 		* Verify a definition node.
@@ -7765,6 +8066,12 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			verifyTextInNode(node);
 		}
 		/**
+		* Verify an inline math node
+		*/
+		function verifyInlineMath(node) {
+			verifyTextInNode(node);
+		}
+		/**
 		* Verify a link node
 		*/
 		function verifyLink(node) {
@@ -7800,6 +8107,26 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			codeText = newCodeText;
 		}
 		/**
+		* Verify a table node.
+		*/
+		function verifyTable(node) {
+			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
+			if (!parsedDelimiterRow) return;
+			verifyTextInRange(node, parsedDelimiterRow.range);
+		}
+		/**
+		* Verify a text node.
+		*/
+		function verifyText(node) {
+			verifyTextInNode(node);
+		}
+		/**
+		* Verify a math block node
+		*/
+		function verifyMathBlock(node) {
+			verifyTextInNode(node);
+		}
+		/**
 		* Verify spaces in a node
 		*/
 		function verifyTextInNode(node) {
@@ -8312,14 +8639,14 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 			}
 		}
 		return {
-			"blockquote, listItem, footnoteDefinition"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				scope = {
 					node,
 					upper: scope,
 					last: null
 				};
 			},
-			"blockquote, listItem, footnoteDefinition:exit"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer:exit"(node) {
 				if (scope.node === node) scope = scope.upper;
 			},
 			heading() {
@@ -8401,14 +8728,14 @@ var ordered_list_marker_start_default = createRule("ordered-list-marker-start",
 			});
 		}
 		return {
-			"blockquote, listItem, footnoteDefinition"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				scope = {
 					node,
 					upper: scope,
 					last: null
 				};
 			},
-			"blockquote, listItem, footnoteDefinition:exit"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer:exit"(node) {
 				if (scope.node === node) scope = scope.upper;
 			},
 			heading() {
@@ -8581,14 +8908,14 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 				if (!node.ordered) return;
 				checkOrderedList(node);
 			},
-			"root, blockquote, listItem, footnoteDefinition"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				containerStack = {
 					node,
 					level: node.type === "listItem" ? containerStack.level + 1 : 1,
 					upper: containerStack
 				};
 			},
-			"root, blockquote, listItem, footnoteDefinition:exit"() {
+			"root, blockquote, listItem, footnoteDefinition, customContainer:exit"() {
 				containerStack = containerStack.upper;
 			}
 		};
@@ -8636,6 +8963,9 @@ const BLOCK_TYPES = [
 	"link-definition",
 	"footnote-definition",
 	"frontmatter",
+	"custom-container",
+	"math",
+	"import-code-snippet",
 	"*"
 ];
 const BLOCK_TYPE_SCHEMAS = [{
@@ -8675,7 +9005,10 @@ const BLOCK_TYPE_MAP = {
 	footnoteDefinition: "footnote-definition",
 	json: "frontmatter",
 	toml: "frontmatter",
-	yaml: "frontmatter"
+	yaml: "frontmatter",
+	customContainer: "custom-container",
+	math: "math",
+	importCodeSnippet: "import-code-snippet"
 };
 /**
 * Get the block type of a node
@@ -8871,10 +9204,10 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 			}
 		}
 		return {
-			"root, blockquote, listItem, footnoteDefinition"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				containerStack.unshift(node);
 			},
-			"root, blockquote, listItem, footnoteDefinition:exit"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer:exit"(node) {
 				checkBlockPadding(node);
 				containerStack.shift();
 			}
@@ -11100,6 +11433,7 @@ const rules$1 = [
 	link_paren_spacing_default,
 	link_title_style_default,
 	list_marker_alignment_default,
+	no_implicit_block_closing_default,
 	no_laziness_blockquotes_default,
 	no_multi_spaces_default,
 	no_multiple_empty_lines_default,
@@ -11150,6 +11484,7 @@ const rules$3 = {
 	"markdown-preferences/blockquote-marker-alignment": "error",
 	"markdown-preferences/hard-linebreak-style": "error",
 	"markdown-preferences/list-marker-alignment": "error",
+	"markdown-preferences/no-implicit-block-closing": "error",
 	"markdown-preferences/no-laziness-blockquotes": "error",
 	"markdown-preferences/no-text-backslash-linebreak": "error",
 	"markdown-preferences/prefer-autolinks": "error",
@@ -11195,6 +11530,7 @@ const rules$2 = {
 	"markdown-preferences/link-paren-spacing": "error",
 	"markdown-preferences/link-title-style": "error",
 	"markdown-preferences/list-marker-alignment": "error",
+	"markdown-preferences/no-implicit-block-closing": "error",
 	"markdown-preferences/no-laziness-blockquotes": "error",
 	"markdown-preferences/no-multi-spaces": "error",
 	"markdown-preferences/no-multiple-empty-lines": "error",
@@ -11224,7 +11560,440 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.26.1";
+const version = "0.28.0";
+
+//#endregion
+//#region src/language/extensions/micromark-custom-container.ts
+/**
+* Micromark extension to support custom containers (e.g., ::: warning ... :::).
+*/
+function customContainer() {
+	const customContainerOpenConstruct = {
+		name: "customContainer",
+		continuation: {
+			name: "customContainerContinuation",
+			tokenize(effects, ok, nok) {
+				return tokenizeCustomContainerContinuation(this, effects, ok, nok);
+			}
+		},
+		exit(effects) {
+			effects.exit("customContainer");
+		},
+		tokenize(effects, ok, nok) {
+			return tokenizeCustomContainerOpen(this, effects, ok, nok);
+		}
+	};
+	const customContainerCloseConstruct = {
+		name: "customContainerCloseConstruct",
+		tokenize(effects, ok, nok) {
+			return tokenizeCustomContainerClose(this, effects, ok, nok);
+		}
+	};
+	return { document: { [codes.colon]: customContainerOpenConstruct } };
+	/**
+	* Continuation tokenizer for the opening marker of the custom container.
+	*/
+	function tokenizeCustomContainerOpen(self, effects, ok, nok) {
+		let size = 0;
+		let openToken;
+		const infoCodes = [];
+		return start;
+		/**
+		* Process start for the opening marker of the custom container.
+		*/
+		function start(code) {
+			if (code !== codes.colon) return nok(code);
+			size = 0;
+			openToken = effects.enter("customContainer", { _container: true });
+			effects.enter("customContainerFence");
+			effects.enter("customContainerFenceSequence");
+			return sequence;
+		}
+		/**
+		* Process sequence for the opening marker of the custom container.
+		*
+		* ```markdown
+		* > | ::: info
+		*     ^
+		* ```
+		*/
+		function sequence(code) {
+			if (code === codes.colon) {
+				size++;
+				effects.consume(code);
+				return sequence;
+			}
+			if (size < 3) return nok(code);
+			effects.exit("customContainerFenceSequence");
+			return markdownSpace(code) ? factorySpace(effects, infoBefore, types.whitespace)(code) : infoBefore(code);
+		}
+		/**
+		* Process before info for the opening marker of the custom container.
+		*
+		* ```markdown
+		* > | ::: info
+		*        ^
+		* ```
+		*/
+		function infoBefore(code) {
+			if (code === codes.eof || markdownLineEnding(code)) return nok(code);
+			openToken._customContainer = { size };
+			self.containerState._customContainer = { open: openToken };
+			effects.enter("customContainerFenceInfo");
+			effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+			infoCodes.length = 0;
+			return info(code);
+		}
+		/**
+		* Process info for the opening marker of the custom container.
+		*
+		* ```markdown
+		* > | ::: info
+		*         ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function info(code) {
+			if (code === codes.eof || markdownLineEnding(code)) {
+				effects.exit(types.chunkString);
+				effects.exit("customContainerFenceInfo");
+				effects.exit("customContainerFence");
+				openToken._customContainer.info = String.fromCharCode(...infoCodes);
+				return ok(code);
+			}
+			infoCodes.push(code);
+			effects.consume(code);
+			return info;
+		}
+	}
+	/**
+	* Continuation tokenizer for the closing marker of the custom container.
+	*/
+	function tokenizeCustomContainerClose(self, effects, ok, nok) {
+		let size = 0;
+		return start;
+		/**
+		* Process start for the closing marker of the custom container.
+		*/
+		function start(code) {
+			if (code !== codes.colon) return nok(code);
+			size = 0;
+			effects.enter("customContainerFence");
+			effects.enter("customContainerFenceSequence");
+			return sequence;
+		}
+		/**
+		* Process sequence for the closing marker of the custom container.
+		*
+		* ```markdown
+		* > | :::
+		* ```
+		*/
+		function sequence(code) {
+			if (code === codes.colon) {
+				size++;
+				effects.consume(code);
+				return sequence;
+			}
+			if (size < 3) return nok(code);
+			effects.exit("customContainerFenceSequence");
+			return markdownSpace(code) ? factorySpace(effects, after, types.whitespace)(code) : after(code);
+		}
+		/**
+		* Process after for the closing marker of the custom container.
+		*
+		* ```markdown
+		* > | :::
+		*        ^
+		* ```
+		*/
+		function after(code) {
+			if (code === codes.eof || markdownLineEnding(code)) {
+				if (!self.containerState) throw new Error("containerState is undefined");
+				const openToken = self.containerState._customContainer?.open;
+				if (openToken?._customContainer?.size === size) {
+					openToken._customContainer.closed = true;
+					self.containerState._closeFlow = true;
+					effects.exit("customContainerFence");
+					return ok(code);
+				}
+			}
+			return nok(code);
+		}
+	}
+	/**
+	* Continuation tokenizer for the custom container.
+	*/
+	function tokenizeCustomContainerContinuation(self, effects, ok, nok) {
+		if (self.containerState?._customContainer?.open?._customContainer?.closed) {
+			self.containerState._closeFlow = true;
+			return nok;
+		}
+		return start;
+		/**
+		* Process start for the custom container.
+		*/
+		function start(code) {
+			if (code !== codes.colon) return ok(code);
+			return effects.attempt(customContainerCloseConstruct, () => {
+				self.containerState._closeFlow = true;
+				return ok;
+			}, ok);
+		}
+	}
+}
+
+//#endregion
+//#region src/language/extensions/mdast-custom-container.ts
+/**
+* Mdast extension to support custom containers (e.g., ::: warning ... :::).
+*/
+function customContainerFromMarkdown() {
+	return {
+		enter: {
+			customContainer(token) {
+				this.enter({
+					type: "customContainer",
+					children: [],
+					info: null
+				}, token);
+			},
+			customContainerFenceInfo() {
+				this.buffer();
+			}
+		},
+		exit: {
+			customContainer(token) {
+				this.exit(token);
+			},
+			customContainerFenceInfo() {
+				const data = this.resume();
+				const node = this.stack[this.stack.length - 1];
+				node.info = data;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/language/extensions/micromark-import-code-snippet.ts
+/**
+* Micromark extension to support [VitePress-style Import Code Snippets](https://vitepress.dev/guide/markdown#import-code-snippets) syntax using triple left angle brackets.
+*/
+function importCodeSnippet() {
+	const importCodeSnippetConstruct = {
+		name: "importCodeSnippet",
+		tokenize(effects, ok, nok) {
+			return tokenizeImportCodeSnippet(this, effects, ok, nok);
+		}
+	};
+	return { flow: { [codes.lessThan]: importCodeSnippetConstruct } };
+	/**
+	* Tokenizer for the import code snippet.
+	*/
+	function tokenizeImportCodeSnippet(_self, effects, ok, nok) {
+		let size = 0;
+		return start;
+		/**
+		* Process start for the opening marker of the import code snippet.
+		*/
+		function start(code) {
+			if (code !== codes.lessThan) return nok(code);
+			size = 0;
+			effects.enter("importCodeSnippet");
+			effects.enter("importCodeSnippetMarkerSequence");
+			return sequence(code);
+		}
+		/**
+		* Process the sequence of opening markers for the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*     ^^^
+		* ```
+		*/
+		function sequence(code) {
+			if (code === codes.lessThan) {
+				size++;
+				effects.consume(code);
+				return sequence;
+			}
+			if (size < 3) return nok(code);
+			effects.exit("importCodeSnippetMarkerSequence");
+			return markdownSpace(code) ? factorySpace(effects, afterMarker, types.whitespace)(code) : afterMarker(code);
+		}
+		/**
+		* Process after the opening marker of the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*         ^
+		* ```
+		*/
+		function afterMarker(code) {
+			if (code === codes.eof || markdownLineEnding(code)) return nok(code);
+			effects.enter("importCodeSnippetPath");
+			effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+			return importPath(code);
+		}
+		/**
+		* Process the path of the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*         ^^^^^^^^^^^^^^^^^
+		* ```
+		*/
+		function importPath(code) {
+			if (code === codes.eof || markdownLineEnding(code) || markdownSpace(code)) {
+				effects.exit(types.chunkString);
+				effects.exit("importCodeSnippetPath");
+				effects.exit("importCodeSnippet");
+				return afterPath(code);
+			}
+			effects.consume(code);
+			return importPath;
+		}
+		/**
+		* Process after the path of the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*                          ^
+		* ```
+		*/
+		function afterPath(code) {
+			if (code === codes.eof || markdownLineEnding(code)) return ok(code);
+			if (markdownSpace(code)) return factorySpace(effects, afterPath, types.whitespace)(code);
+			return nok(code);
+		}
+	}
+}
+
+//#endregion
+//#region src/language/extensions/mdast-import-code-snippet.ts
+/**
+* Mdast extension to support [VitePress-style Import Code Snippets](https://vitepress.dev/guide/markdown#import-code-snippets) syntax using triple left angle brackets.
+*/
+function importCodeSnippetFromMarkdown() {
+	return {
+		enter: {
+			importCodeSnippet(token) {
+				this.enter({
+					type: "importCodeSnippet",
+					value: ""
+				}, token);
+			},
+			importCodeSnippetPath() {
+				this.buffer();
+			}
+		},
+		exit: {
+			importCodeSnippet(token) {
+				this.exit(token);
+			},
+			importCodeSnippetPath() {
+				const data = this.resume();
+				const node = this.stack[this.stack.length - 1];
+				node.value = data;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/language/parser.ts
+/**
+* Parse Extended Markdown to MDAST.
+*/
+function parseExtendedMarkdown(code) {
+	const options = {
+		extensions: [
+			gfm(),
+			frontmatter(["yaml", "toml"]),
+			math(),
+			customContainer(),
+			importCodeSnippet()
+		],
+		mdastExtensions: [
+			gfmFromMarkdown(),
+			frontmatterFromMarkdown(["yaml", "toml"]),
+			mathFromMarkdown(),
+			customContainerFromMarkdown(),
+			importCodeSnippetFromMarkdown()
+		]
+	};
+	return fromMarkdown(code, options);
+}
+
+//#endregion
+//#region src/language/extended-markdown-language.ts
+var ExtendedMarkdownLanguage = class {
+	/**
+	* The type of file to read.
+	* @type {"text"}
+	*/
+	fileType = markdown.languages.gfm.fileType;
+	/**
+	* The line number at which the parser starts counting.
+	* @type {0|1}
+	*/
+	lineStart = markdown.languages.gfm.lineStart;
+	/**
+	* The column number at which the parser starts counting.
+	* @type {0|1}
+	*/
+	columnStart = markdown.languages.gfm.columnStart;
+	/**
+	* The name of the key that holds the type of the node.
+	* @type {string}
+	*/
+	nodeTypeKey = markdown.languages.gfm.nodeTypeKey;
+	/**
+	* Default language options. User-defined options are merged with this object.
+	* @type {MarkdownLanguageOptions}
+	*/
+	defaultLanguageOptions = markdown.languages.gfm.defaultLanguageOptions;
+	/**
+	* Validates the language options.
+	* @param {MarkdownLanguageOptions} languageOptions The language options to validate.
+	* @returns {void}
+	* @throws {Error} When the language options are invalid.
+	*/
+	validateLanguageOptions(languageOptions$2) {
+		return markdown.languages.gfm.validateLanguageOptions(languageOptions$2);
+	}
+	/**
+	* Parses the given file into an AST.
+	* @param {File} file The virtual file to parse.
+	* @param {MarkdownLanguageContext} _context The options to use for parsing.
+	* @returns {ParseResult<Root>} The result of parsing.
+	*/
+	parse(file, _context) {
+		const text = file.body;
+		try {
+			return {
+				ok: true,
+				ast: parseExtendedMarkdown(text)
+			};
+		} catch (ex) {
+			return {
+				ok: false,
+				errors: [ex]
+			};
+		}
+	}
+	/**
+	* Creates a new `MarkdownSourceCode` object from the given information.
+	* @param {File} file The virtual file to create a `MarkdownSourceCode` object from.
+	* @param {OkParseResult<Root>} parseResult The result returned from `parse()`.
+	* @returns {MarkdownSourceCode} The new `MarkdownSourceCode` object.
+	*/
+	createSourceCode(file, parseResult) {
+		return markdown.languages.gfm.createSourceCode(file, parseResult);
+	}
+};
 
 //#endregion
 //#region src/index.ts
@@ -11240,12 +12009,14 @@ const resources = {
 	defaultPreserveWords,
 	defaultMinorWords
 };
+const languages = { "extended-syntax": new ExtendedMarkdownLanguage() };
 var src_default = {
 	meta: meta_exports,
+	languages,
 	configs,
 	rules,
 	resources
 };
 
 //#endregion
-export { configs, src_default as default, meta_exports as meta, resources, rules };
+export { configs, src_default as default, languages, meta_exports as meta, resources, rules };