eslint-plugin-markdown-preferences 0.27.0 → 0.29.0

package/README.md

@@ -164,24 +164,25 @@ The rules with the following 💄 are included in the `standard` config.
 
 <!-- prettier-ignore-start -->
 
-| Rule ID                                                                                                                                                               | Description                                                                               | Fixable | Config |
-| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- | :-----: | :----: |
-| [markdown-preferences/bullet-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/bullet-list-marker-style.html)                   | enforce consistent bullet list (unordered list) marker style                              |   🔧    |   💄   |
-| [markdown-preferences/code-fence-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html)                                   | enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks. |   🔧    |   💄   |
-| [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html)                                   | require link definitions and footnote definitions to be placed at the end of the document |   🔧    |        |
-| [markdown-preferences/emphasis-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emphasis-delimiters-style.html)                 | enforce a consistent delimiter style for emphasis and strong emphasis                     |   🔧    |   💄   |
-| [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html)                           | enforce consistent hard linebreak style.                                                  |   🔧    |  ⭐💄  |
-| [markdown-preferences/level1-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level1-heading-style.html)                           | enforce consistent style for level 1 headings                                             |   🔧    |   💄   |
-| [markdown-preferences/level2-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level2-heading-style.html)                           | enforce consistent style for level 2 headings                                             |   🔧    |   💄   |
-| [markdown-preferences/link-destination-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-destination-style.html)                       | enforce a consistent style for link destinations                                          |   🔧    |   💄   |
-| [markdown-preferences/link-title-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-title-style.html)                                   | enforce a consistent style for link titles                                                |   🔧    |   💄   |
-| [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html)             | disallow text backslash at the end of a line.                                             |         |  ⭐💄  |
-| [markdown-preferences/ordered-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html)                 | enforce consistent ordered list marker style                                              |   🔧    |   💄   |
-| [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html)                                   | enforce the use of autolinks for URLs                                                     |   🔧    |  ⭐💄  |
-| [markdown-preferences/prefer-fenced-code-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html)                 | enforce the use of fenced code blocks over indented code blocks                           |   🔧    |  ⭐💄  |
-| [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links                          |   🔧    |        |
-| [markdown-preferences/strikethrough-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/strikethrough-delimiters-style.html)       | enforce a consistent delimiter style for strikethrough                                    |   🔧    |   💄   |
-| [markdown-preferences/thematic-break-character-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-character-style.html)       | enforce consistent character style for thematic breaks (horizontal rules) in Markdown.    |   🔧    |   💄   |
+| Rule ID                                                                                                                                                               | Description                                                                                | Fixable | Config |
+| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------- | :-----: | :----: |
+| [markdown-preferences/bullet-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/bullet-list-marker-style.html)                   | enforce consistent bullet list (unordered list) marker style                               |   🔧    |   💄   |
+| [markdown-preferences/code-fence-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html)                                   | enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.  |   🔧    |   💄   |
+| [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html)                                   | require link definitions and footnote definitions to be placed at the end of the document  |   🔧    |        |
+| [markdown-preferences/emphasis-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emphasis-delimiters-style.html)                 | enforce a consistent delimiter style for emphasis and strong emphasis                      |   🔧    |   💄   |
+| [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html)                           | enforce consistent hard linebreak style.                                                   |   🔧    |  ⭐💄  |
+| [markdown-preferences/level1-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level1-heading-style.html)                           | enforce consistent style for level 1 headings                                              |   🔧    |   💄   |
+| [markdown-preferences/level2-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level2-heading-style.html)                           | enforce consistent style for level 2 headings                                              |   🔧    |   💄   |
+| [markdown-preferences/link-destination-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-destination-style.html)                       | enforce a consistent style for link destinations                                           |   🔧    |   💄   |
+| [markdown-preferences/link-title-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-title-style.html)                                   | enforce a consistent style for link titles                                                 |   🔧    |   💄   |
+| [markdown-preferences/no-implicit-block-closing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-implicit-block-closing.html)                 | disallow implicit block closing for fenced code blocks, math blocks, and custom containers |   🔧    |  ⭐💄  |
+| [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html)             | disallow text backslash at the end of a line.                                              |         |  ⭐💄  |
+| [markdown-preferences/ordered-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html)                 | enforce consistent ordered list marker style                                               |   🔧    |   💄   |
+| [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html)                                   | enforce the use of autolinks for URLs                                                      |   🔧    |  ⭐💄  |
+| [markdown-preferences/prefer-fenced-code-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html)                 | enforce the use of fenced code blocks over indented code blocks                            |   🔧    |  ⭐💄  |
+| [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links                           |   🔧    |        |
+| [markdown-preferences/strikethrough-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/strikethrough-delimiters-style.html)       | enforce a consistent delimiter style for strikethrough                                     |   🔧    |   💄   |
+| [markdown-preferences/thematic-break-character-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-character-style.html)       | enforce consistent character style for thematic breaks (horizontal rules) in Markdown.     |   🔧    |   💄   |
 
 <!-- prettier-ignore-end -->
 
@@ -203,6 +204,7 @@ The rules with the following 💄 are included in the `standard` config.
 | [markdown-preferences/no-multi-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multi-spaces.html)                         | disallow multiple spaces                                             |   🔧    |   💄   |
 | [markdown-preferences/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html)         | disallow multiple empty lines in Markdown files.                     |   🔧    |   💄   |
 | [markdown-preferences/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html)                   | disallow trailing whitespace at the end of lines in Markdown files.  |   🔧    |   💄   |
+| [markdown-preferences/padded-custom-containers](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padded-custom-containers.html)       | disallow or require padding inside custom containers                 |   🔧    |   💄   |
 | [markdown-preferences/padding-line-between-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html) | require or disallow padding lines between blocks                     |   🔧    |   💄   |
 | [markdown-preferences/table-pipe-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-pipe-spacing.html)                   | enforce consistent spacing around table pipes                        |   🔧    |   💄   |
 

package/lib/index.d.ts

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

package/lib/index.js

@@ -989,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 = "";
@@ -1019,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,
@@ -1227,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);
 				}
 			});
 		}
@@ -1267,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;
@@ -1327,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)));
 				}
 			});
 		} };
@@ -5323,7 +5315,19 @@ function parseMathBlock(sourceCode, node) {
 		loc: getSourceLocationFromRange(sourceCode, node, openingSequenceRange)
 	};
 	const parsedClosing = parseMathClosingSequenceFromText(text);
-	if (parsedClosing == null) return null;
+	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,
@@ -5891,7 +5895,7 @@ var indent_default = createRule("indent", {
 			const parsed = parseMathBlock(sourceCode, node);
 			if (!parsed) return;
 			const loc = sourceCode.getLoc(node);
-			const endLineToBeChecked = inlineToBeChecked(parsed.closingSequence.loc.start);
+			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
@@ -7541,6 +7545,164 @@ 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 containers",
+			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) return;
+				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) return;
+				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) return;
+				context.report({
+					node,
+					loc: parsed.openingSequence.loc,
+					messageId: "missingClosingContainer",
+					fix(fixer) {
+						if (withinSameLengthOpeningCustomContainer(sourceCode, node, parsed.openingSequence.text.length)) return null;
+						const openingLoc = parsed.openingSequence.loc;
+						const prefix = sourceCode.lines[openingLoc.start.line - 1].slice(0, openingLoc.start.column - 1).replace(/[^\s>]/gu, " ");
+						const closingSequence = parsed.openingSequence.text;
+						return fixer.insertTextAfter(node, `\n${prefix}${closingSequence}`);
+					}
+				});
+			}
+		};
+	}
+});
+/**
+* Check if the given custom container node is within another custom container
+* that has the same length of opening sequence.
+*
+*/
+function withinSameLengthOpeningCustomContainer(sourceCode, node, openingLength) {
+	let current = getParent(sourceCode, node);
+	while (current) {
+		if (current.type === "customContainer") {
+			const parsed = parseCustomContainer(sourceCode, current);
+			if (!parsed) return true;
+			if (parsed.openingSequence.text.length === openingLength) return true;
+		}
+		current = getParent(sourceCode, current);
+	}
+	return false;
+}
+
 //#endregion
 //#region src/rules/no-laziness-blockquotes.ts
 var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
@@ -7854,31 +8016,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.
@@ -7919,6 +8087,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) {
@@ -7954,6 +8128,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) {
@@ -8749,6 +8943,101 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 	}
 });
 
+//#endregion
+//#region src/rules/padded-custom-containers.ts
+var padded_custom_containers_default = createRule("padded-custom-containers", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "disallow or require padding inside custom containers",
+			categories: ["standard"],
+			listCategory: "Whitespace"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { padding: {
+				type: "string",
+				enum: ["always", "never"],
+				default: "never"
+			} },
+			additionalProperties: false
+		}],
+		messages: {
+			expectedPaddingAfterOpeningMarker: "Expected padding after opening marker.",
+			expectedPaddingBeforeClosingMarker: "Expected padding before closing marker.",
+			unexpectedPaddingAfterOpeningMarker: "Unexpected padding after opening marker.",
+			unexpectedPaddingBeforeClosingMarker: "Unexpected padding before closing marker."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const padding = (context.options[0] || {}).padding || "never";
+		return { customContainer(node) {
+			if (node.children.length === 0) return;
+			const parsed = parseCustomContainer(sourceCode, node);
+			if (!parsed) return;
+			const { openingSequence, closingSequence } = parsed;
+			const firstChild = node.children[0];
+			const lastChild = node.children[node.children.length - 1];
+			const firstChildLoc = sourceCode.getLoc(firstChild);
+			const lastChildLoc = sourceCode.getLoc(lastChild);
+			const paddingAfterOpeningLines = firstChildLoc.start.line - openingSequence.loc.end.line - 1;
+			const paddingBeforeClosingLines = closingSequence ? closingSequence.loc.start.line - lastChildLoc.end.line - 1 : null;
+			if (padding === "always") {
+				if (paddingAfterOpeningLines <= 0) {
+					const reportEndToken = parsed.info ?? openingSequence;
+					const reportRange = [openingSequence.range[0], reportEndToken.range[1]];
+					context.report({
+						messageId: "expectedPaddingAfterOpeningMarker",
+						loc: getSourceLocationFromRange(sourceCode, node, reportRange),
+						fix(fixer) {
+							return fixer.insertTextAfterRange(reportRange, "\n");
+						}
+					});
+				}
+				if (closingSequence && paddingBeforeClosingLines !== null && paddingBeforeClosingLines <= 0) context.report({
+					messageId: "expectedPaddingBeforeClosingMarker",
+					loc: getSourceLocationFromRange(sourceCode, node, closingSequence.range),
+					fix(fixer) {
+						return fixer.insertTextBeforeRange([closingSequence.range[0] - closingSequence.loc.start.column + 1, closingSequence.range[1]], "\n");
+					}
+				});
+			} else if (padding === "never") {
+				if (paddingAfterOpeningLines > 0) {
+					const firstChildRange = sourceCode.getRange(firstChild);
+					context.report({
+						messageId: "unexpectedPaddingAfterOpeningMarker",
+						loc: getSourceLocationFromRange(sourceCode, node, [openingSequence.range[1], firstChildRange[0]]),
+						*fix(fixer) {
+							const lines = getParsedLines(sourceCode);
+							for (let lineNumber = openingSequence.loc.end.line + 1; lineNumber < firstChildLoc.start.line; lineNumber++) {
+								const line = lines.get(lineNumber);
+								yield fixer.removeRange(line.range);
+							}
+						}
+					});
+				}
+				if (closingSequence && paddingBeforeClosingLines !== null && paddingBeforeClosingLines > 0) {
+					const lastChildRange = sourceCode.getRange(lastChild);
+					context.report({
+						messageId: "unexpectedPaddingBeforeClosingMarker",
+						loc: getSourceLocationFromRange(sourceCode, node, [lastChildRange[1], closingSequence.range[0]]),
+						*fix(fixer) {
+							const lines = getParsedLines(sourceCode);
+							for (let lineNumber = lastChildLoc.end.line + 1; lineNumber < closingSequence.loc.start.line; lineNumber++) {
+								const line = lines.get(lineNumber);
+								yield fixer.removeRange(line.range);
+							}
+						}
+					});
+				}
+			}
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/padding-line-between-blocks.ts
 /**
@@ -11260,6 +11549,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,
@@ -11268,6 +11558,7 @@ const rules$1 = [
 	ordered_list_marker_sequence_default,
 	ordered_list_marker_start_default,
 	ordered_list_marker_style_default,
+	padded_custom_containers_default,
 	padding_line_between_blocks_default,
 	prefer_autolinks_default,
 	prefer_fenced_code_blocks_default,
@@ -11310,6 +11601,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",
@@ -11355,6 +11647,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",
@@ -11363,6 +11656,7 @@ const rules$2 = {
 	"markdown-preferences/ordered-list-marker-sequence": "error",
 	"markdown-preferences/ordered-list-marker-start": "error",
 	"markdown-preferences/ordered-list-marker-style": "error",
+	"markdown-preferences/padded-custom-containers": "error",
 	"markdown-preferences/padding-line-between-blocks": "error",
 	"markdown-preferences/prefer-autolinks": "error",
 	"markdown-preferences/prefer-fenced-code-blocks": "error",
@@ -11384,7 +11678,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.27.0";
+const version = "0.29.0";
 
 //#endregion
 //#region src/language/extensions/micromark-custom-container.ts
@@ -11752,7 +12046,7 @@ function parseExtendedMarkdown(code) {
 }
 
 //#endregion
-//#region src/language/extended-markdown-ianguage.ts
+//#region src/language/extended-markdown-language.ts
 var ExtendedMarkdownLanguage = class {
 	/**
 	* The type of file to read.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {