eslint-plugin-markdown-preferences 0.27.0 → 0.28.0

package/README.md

@@ -175,6 +175,7 @@ The rules with the following 💄 are included in the `standard` config.
 | [markdown-preferences/level2-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level2-heading-style.html)                           | enforce consistent style for level 2 headings                                             |   🔧    |   💄   |
 | [markdown-preferences/link-destination-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-destination-style.html)                       | enforce a consistent style for link destinations                                          |   🔧    |   💄   |
 | [markdown-preferences/link-title-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-title-style.html)                                   | enforce a consistent style for link titles                                                |   🔧    |   💄   |
+| [markdown-preferences/no-implicit-block-closing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-implicit-block-closing.html)                 | disallow implicit block closing for fenced code blocks, math blocks, and custom blocks    |   🔧    |  ⭐💄  |
 | [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html)             | disallow text backslash at the end of a line.                                             |         |  ⭐💄  |
 | [markdown-preferences/ordered-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html)                 | enforce consistent ordered list marker style                                              |   🔧    |   💄   |
 | [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html)                                   | enforce the use of autolinks for URLs                                                     |   🔧    |  ⭐💄  |

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 blocks
+   * @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
@@ -503,7 +508,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.28.0";
 //#endregion
 //#region src/language/ast-types.d.ts
 type Node = mdast.Node;
@@ -600,7 +605,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,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", {
@@ -7854,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.
@@ -7919,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) {
@@ -7954,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) {
@@ -11260,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,
@@ -11310,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",
@@ -11355,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",
@@ -11384,7 +11560,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.27.0";
+const version = "0.28.0";
 
 //#endregion
 //#region src/language/extensions/micromark-custom-container.ts
@@ -11752,7 +11928,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.28.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {