eslint-plugin-markdown-preferences 0.9.0 → 0.11.0

package/README.md

@@ -50,7 +50,7 @@ Example **eslint.config.js**:
 ```js
 import { defineConfig } from "eslint/config";
 // import markdown from "@eslint/markdown";
-import markdownPreferences from 'eslint-plugin-markdown-preferences';
+import markdownPreferences from "eslint-plugin-markdown-preferences";
 export default [
   // add more generic rule sets here, such as:
   // markdown.configs.recommended,
@@ -59,8 +59,8 @@ export default [
     rules: {
       // override/add rules settings here, such as:
       // 'markdown-preferences/prefer-linked-words': 'error'
-    }
-  }
+    },
+  },
 ];
 ```
 
@@ -86,10 +86,13 @@ The rules with the following star ⭐ are included in the configs.
 
 <!--RULES_TABLE_START-->
 
+<!-- prettier-ignore-start -->
+
 ### Preference Rules
 
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
+| [markdown-preferences/canonical-code-block-language](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html) | enforce canonical language names in code 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/prefer-inline-code-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-inline-code-words.html) | enforce the use of inline code for specific words. | 🔧 |  |
 | [markdown-preferences/prefer-linked-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html) | enforce the specified word to be a link. | 🔧 |  |
@@ -98,14 +101,19 @@ The rules with the following star ⭐ are included in the configs.
 
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
-| [markdown-preferences/canonical-code-block-language](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html) | enforce canonical language names in 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/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html) | enforce consistent hard linebreak style. | 🔧 | ⭐ |
 | [markdown-preferences/heading-casing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html) | enforce consistent casing in headings. | 🔧 |  |
+| [markdown-preferences/no-laziness-blockquotes](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html) | disallow laziness in blockquotes |  | ⭐ |
+| [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/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/sort-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html) | enforce a specific order for link definitions and footnote definitions | 🔧 |  |
 
+<!-- prettier-ignore-end -->
+
 <!--RULES_TABLE_END-->
 <!--RULES_SECTION_END-->
 <!--DOCS_IGNORE_START-->
@@ -123,7 +131,7 @@ Please use GitHub's Issues/PRs.
 
 ## 🔒 License
 
-See the [LICENSE](LICENSE) file for license rights and limitations (MIT).
+See the [LICENSE](./LICENSE) file for license rights and limitations (MIT).
 
 [npm-package]: https://www.npmjs.com/package/eslint-plugin-markdown-preferences
 [npmtrends]: http://www.npmtrends.com/eslint-plugin-markdown-preferences

package/lib/index.d.ts

@@ -30,6 +30,16 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html
    */
   'markdown-preferences/heading-casing'?: Linter.RuleEntry<MarkdownPreferencesHeadingCasing>;
+  /**
+   * disallow laziness in blockquotes
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html
+   */
+  'markdown-preferences/no-laziness-blockquotes'?: Linter.RuleEntry<[]>;
+  /**
+   * disallow multiple empty lines in Markdown files.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html
+   */
+  'markdown-preferences/no-multiple-empty-lines'?: Linter.RuleEntry<MarkdownPreferencesNoMultipleEmptyLines>;
   /**
    * disallow text backslash at the end of a line.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html
@@ -40,6 +50,16 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html
    */
   'markdown-preferences/no-trailing-spaces'?: Linter.RuleEntry<MarkdownPreferencesNoTrailingSpaces>;
+  /**
+   * enforce the use of autolinks for URLs
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html
+   */
+  'markdown-preferences/prefer-autolinks'?: Linter.RuleEntry<[]>;
+  /**
+   * enforce the use of fenced code blocks over indented code blocks
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html
+   */
+  'markdown-preferences/prefer-fenced-code-blocks'?: Linter.RuleEntry<[]>;
   /**
    * enforce the use of inline code for specific words.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-inline-code-words.html
@@ -75,6 +95,11 @@ type MarkdownPreferencesHeadingCasing = [] | [{
   ignorePatterns?: string[];
   minorWords?: string[];
 }];
+type MarkdownPreferencesNoMultipleEmptyLines = [] | [{
+  max?: number;
+  maxEOF?: number;
+  maxBOF?: number;
+}];
 type MarkdownPreferencesNoTrailingSpaces = [] | [{
   skipBlankLines?: boolean;
   ignoreComments?: boolean;
@@ -114,11 +139,14 @@ type MarkdownPreferencesSortDefinitions = [] | [{
   alphabetical?: boolean;
 }];
 declare namespace recommended_d_exports {
-  export { files, language, name$1 as name, plugins, rules$1 as rules };
+  export { files, language, languageOptions, name$1 as name, plugins, rules$1 as rules };
 }
 declare const name$1 = "markdown-preferences/recommended";
 declare const files: string[];
-declare const language = "markdown/commonmark";
+declare const language = "markdown/gfm";
+declare const languageOptions: {
+  frontmatter: string;
+};
 declare const plugins: {
   markdown: typeof markdown;
   readonly "markdown-preferences": ESLint.Plugin;
@@ -128,7 +156,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.9.0";
+declare const version: "0.11.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -56,7 +56,7 @@ var canonical_code_block_language_default = createRule("canonical-code-block-lan
 		docs: {
 			description: "enforce canonical language names in code blocks",
 			categories: [],
-			listCategory: "Stylistic"
+			listCategory: "Preference"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -978,6 +978,333 @@ var heading_casing_default = createRule("heading-casing", {
 	}
 });
 
+//#endregion
+//#region src/utils/lines.ts
+const cache = /* @__PURE__ */ new WeakMap();
+var ParsedLines = class {
+	lines;
+	constructor(codeText) {
+		let offset = 0;
+		this.lines = codeText.split(/(?<=\n)/u).map((lineText, index) => {
+			const start = offset;
+			offset += lineText.length;
+			const range = [start, offset];
+			let text = lineText;
+			let linebreak = "";
+			if (text.at(-1) === "\n") {
+				text = text.slice(0, -1);
+				linebreak = "\n";
+			}
+			if (text.at(-1) === "\r") {
+				text = text.slice(0, -1);
+				linebreak = `\r${linebreak}`;
+			}
+			return {
+				text,
+				range,
+				line: index + 1,
+				linebreak
+			};
+		});
+	}
+	[Symbol.iterator]() {
+		return this.lines[Symbol.iterator]();
+	}
+	get length() {
+		return this.lines.length;
+	}
+	get(lineNumber) {
+		return this.lines[lineNumber - 1];
+	}
+};
+/**
+* Parse the lines of the source code.
+* @param sourceCode source code to parse
+* @returns parsed lines
+*/
+function parseLines(sourceCode) {
+	const cached = cache.get(sourceCode);
+	if (cached) return cached;
+	const parsedLines = new ParsedLines(sourceCode.text);
+	cache.set(sourceCode, parsedLines);
+	return parsedLines;
+}
+
+//#endregion
+//#region src/rules/no-laziness-blockquotes.ts
+/**
+* Helper function to get blockquote line information.
+*/
+function getBlockquoteLineInfo(line) {
+	const regex = /^\s*(?:>\s*)*/u;
+	const match = regex.exec(line.text);
+	return {
+		line,
+		prefix: match[0],
+		level: (match[0].match(/>/gu) || []).length
+	};
+}
+var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "disallow laziness in blockquotes",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: void 0,
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			lazyBlockquoteLine: "Expected {{level}} '>' marker(s), but found {{actualLevel}}. This line will be interpreted as part of level {{level}} blockquote.",
+			addMarker: "Add {{missingMarkers}} '>' marker(s).",
+			addLineBreak: "Add line break to separate from blockquote."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const checkedLines = /* @__PURE__ */ new Set();
+		const lines = parseLines(sourceCode);
+		/**
+		* Report invalid blockquote lines.
+		*/
+		function reportInvalidLines(invalidLines, base) {
+			const invalidGroups = [];
+			for (const invalidLine of invalidLines) {
+				const currentGroup = invalidGroups.at(-1);
+				if (!currentGroup || currentGroup.level < invalidLine.level) {
+					invalidGroups.push({
+						level: invalidLine.level,
+						lines: [invalidLine]
+					});
+					continue;
+				}
+				if (currentGroup.level === invalidLine.level) {
+					currentGroup.lines.push(invalidLine);
+					continue;
+				}
+				if (invalidLine.level < currentGroup.level) break;
+			}
+			for (const group of invalidGroups) {
+				const first = group.lines[0];
+				const last = group.lines.at(-1);
+				context.report({
+					loc: {
+						start: {
+							line: first.line.line,
+							column: 1
+						},
+						end: {
+							line: last.line.line,
+							column: last.line.text.length + 1
+						}
+					},
+					messageId: "lazyBlockquoteLine",
+					data: {
+						level: `${base.level}`,
+						actualLevel: `${group.level}`
+					},
+					suggest: [{
+						messageId: "addMarker",
+						data: { missingMarkers: `${base.level - group.level}` },
+						*fix(fixer) {
+							for (const invalidLine of group.lines) yield fixer.replaceTextRange([invalidLine.line.range[0], invalidLine.line.range[0] + invalidLine.prefix.length], base.prefix);
+						}
+					}, {
+						messageId: "addLineBreak",
+						fix: (fixer) => {
+							return fixer.insertTextBeforeRange([first.line.range[0], first.line.range[0]], `${first.prefix.trimEnd()}\n`);
+						}
+					}]
+				});
+			}
+		}
+		return { "blockquote:exit"(node) {
+			const loc = sourceCode.getLoc(node);
+			const startLine = loc.start.line;
+			const endLine = loc.end.line;
+			const base = getBlockquoteLineInfo(lines.get(startLine));
+			const invalidLines = [];
+			for (let lineNumber = startLine + 1; lineNumber <= endLine; lineNumber++) {
+				if (checkedLines.has(lineNumber)) {
+					reportInvalidLines(invalidLines, base);
+					invalidLines.length = 0;
+					continue;
+				}
+				checkedLines.add(lineNumber);
+				const line = lines.get(lineNumber);
+				const current = getBlockquoteLineInfo(line);
+				if (base.level <= current.level) {
+					reportInvalidLines(invalidLines, base);
+					invalidLines.length = 0;
+					continue;
+				}
+				invalidLines.push(current);
+			}
+			reportInvalidLines(invalidLines, base);
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-multiple-empty-lines.ts
+var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "disallow multiple empty lines in Markdown files.",
+			categories: null,
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				max: {
+					type: "integer",
+					minimum: 0,
+					default: 1
+				},
+				maxEOF: {
+					type: "integer",
+					minimum: 0,
+					default: 0
+				},
+				maxBOF: {
+					type: "integer",
+					minimum: 0,
+					default: 0
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			blankBeginningOfFile: "Too many blank lines at the beginning of file. Max of {{max}} allowed.",
+			blankEndOfFile: "Too many blank lines at the end of file. Max of {{max}} allowed.",
+			consecutiveBlank: "More than {{max}} blank {{pluralizedLines}} not allowed."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = context.options[0] || {};
+		const max = typeof option.max === "number" ? option.max : 1;
+		const maxEOF = typeof option.maxEOF === "number" ? option.maxEOF : 0;
+		const maxBOF = typeof option.maxBOF === "number" ? option.maxBOF : 0;
+		const ignoreLocs = [];
+		/**
+		* Register the range of nodes to ignore (code, html, yaml, toml, json)
+		* @param node mdast node
+		*/
+		function addIgnoreLoc(node) {
+			const loc = sourceCode.getLoc(node);
+			ignoreLocs.push({
+				startLine: loc.start.line,
+				endLine: loc.end.line
+			});
+		}
+		return {
+			code: addIgnoreLoc,
+			html: addIgnoreLoc,
+			yaml: addIgnoreLoc,
+			toml: addIgnoreLoc,
+			json: addIgnoreLoc,
+			"root:exit"() {
+				const lines = [...parseLines(sourceCode)];
+				const bofEmptyLines = [];
+				while (lines.length) {
+					if (lines[0].text.trim()) break;
+					bofEmptyLines.push(lines.shift());
+				}
+				const invalidBOFEmptyLines = bofEmptyLines.slice(maxBOF);
+				if (invalidBOFEmptyLines.length > 0) {
+					const first = invalidBOFEmptyLines[0];
+					const last = invalidBOFEmptyLines[invalidBOFEmptyLines.length - 1];
+					context.report({
+						loc: {
+							start: {
+								line: first.line,
+								column: 1
+							},
+							end: {
+								line: last.line,
+								column: last.text.length + 1
+							}
+						},
+						messageId: "blankBeginningOfFile",
+						data: { max: maxBOF },
+						fix(fixer) {
+							return fixer.removeRange([first.range[0], last.range[1]]);
+						}
+					});
+				}
+				const eofEmptyLines = [];
+				while (lines.length) {
+					if (lines[lines.length - 1].text.trim()) break;
+					eofEmptyLines.unshift(lines.pop());
+				}
+				const invalidEOFEmptyLines = eofEmptyLines.slice(maxEOF);
+				if (invalidEOFEmptyLines.length > 0) {
+					const first = invalidEOFEmptyLines[0];
+					const last = invalidEOFEmptyLines[invalidEOFEmptyLines.length - 1];
+					context.report({
+						loc: {
+							start: {
+								line: first.line,
+								column: 1
+							},
+							end: {
+								line: last.line,
+								column: last.text.length + 1
+							}
+						},
+						messageId: "blankEndOfFile",
+						data: { max: maxEOF },
+						fix(fixer) {
+							return fixer.removeRange([first.range[0], last.range[1]]);
+						}
+					});
+				}
+				const emptyLines = [];
+				for (const lineInfo of lines) {
+					if (!lineInfo.text.trim() && !ignoreLocs.some(({ startLine, endLine }) => {
+						return lineInfo.line > startLine && lineInfo.line < endLine;
+					})) {
+						emptyLines.push(lineInfo);
+						continue;
+					}
+					const invalidEmptyLines = emptyLines.slice(max);
+					emptyLines.length = 0;
+					if (invalidEmptyLines.length) {
+						const first = invalidEmptyLines[0];
+						const last = invalidEmptyLines[invalidEmptyLines.length - 1];
+						context.report({
+							loc: {
+								start: {
+									line: first.line,
+									column: 1
+								},
+								end: {
+									line: last.line,
+									column: last.text.length + 1
+								}
+							},
+							messageId: "consecutiveBlank",
+							data: {
+								max,
+								pluralizedLines: max === 1 ? "line" : "lines"
+							},
+							fix(fixer) {
+								return fixer.removeRange([first.range[0], last.range[1]]);
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/no-text-backslash-linebreak.ts
 var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebreak", {
@@ -1109,51 +1436,170 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 			"root:exit"() {
 				const re = /[^\S\n\r]+$/u;
 				const skipMatch = /^[^\S\n\r]*$/u;
-				const lines = sourceCode.lines;
-				const linebreaks = sourceCode.text.match(/\r?\n/gu);
+				const lines = parseLines(sourceCode);
 				const commentLineNumbers = getCommentLineNumbers();
-				let totalLength = 0;
-				for (let i = 0, ii = lines.length; i < ii; i++) {
-					const lineNumber = i + 1;
-					const linebreakLength = linebreaks && linebreaks[i] ? linebreaks[i].length : 1;
-					const lineLength = lines[i].length + linebreakLength;
-					const matches = re.exec(lines[i]);
-					if (!matches) {
-						totalLength += lineLength;
-						continue;
-					}
+				for (const lineInfo of lines) {
+					const matches = re.exec(lineInfo.text);
+					if (!matches) continue;
 					const location = {
 						start: {
-							line: lineNumber,
+							line: lineInfo.line,
 							column: matches.index + 1
 						},
 						end: {
-							line: lineNumber,
-							column: lineLength + 1 - linebreakLength
+							line: lineInfo.line,
+							column: matches.index + 1 + matches[0].length
 						}
 					};
-					const rangeStart = totalLength + location.start.column - 1;
-					const rangeEnd = totalLength + location.end.column - 1;
+					const range = [lineInfo.range[0] + location.start.column - 1, lineInfo.range[0] + location.end.column - 1];
 					if (ignoreNodes.some((node) => {
-						const range = sourceCode.getRange(node);
-						return range[0] <= rangeStart && rangeEnd <= range[1];
-					})) {
-						totalLength += lineLength;
-						continue;
-					}
-					if (skipBlankLines && skipMatch.test(lines[i])) {
-						totalLength += lineLength;
-						continue;
-					}
-					const fixRange = [rangeStart, rangeEnd];
-					if (!ignoreComments || !commentLineNumbers.has(lineNumber)) report(location, fixRange);
-					totalLength += lineLength;
+						const nodeRange = sourceCode.getRange(node);
+						return nodeRange[0] <= range[0] && range[1] <= nodeRange[1];
+					})) continue;
+					if (skipBlankLines && skipMatch.test(lineInfo.text)) continue;
+					if (!ignoreComments || !commentLineNumbers.has(lineInfo.line)) report(location, range);
 				}
 			}
 		};
 	}
 });
 
+//#endregion
+//#region src/utils/ast.ts
+/**
+* Get the kind of code block.
+*/
+function getCodeBlockKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("```") ? "backtick-fenced" : text.startsWith("~~~") ? "tilde-fenced" : "indented";
+}
+/**
+* Get the kind of link.
+*/
+function getLinkKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("[") ? "inline" : text.startsWith("<") && text.endsWith(">") ? "autolink" : "gfm-autolink";
+}
+
+//#endregion
+//#region src/rules/prefer-autolinks.ts
+var prefer_autolinks_default = createRule("prefer-autolinks", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce the use of autolinks for URLs",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [],
+		messages: {
+			useAutolinkInsteadGFMAutolink: "Use an autolink instead of a GFM autolink (bare url).",
+			useAutolinkInsteadInlineLink: "Use an autolink instead of an inline link with the same URL."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return { link(node) {
+			const kind = getLinkKind(sourceCode, node);
+			if (kind === "autolink") return;
+			if (node.title) return;
+			if (node.children.some((child) => child.type !== "text")) return;
+			const label = node.children.map((child) => child.value).join("");
+			if (node.url !== label) return;
+			context.report({
+				node,
+				messageId: kind === "inline" ? "useAutolinkInsteadInlineLink" : "useAutolinkInsteadGFMAutolink",
+				fix(fixer) {
+					return fixer.replaceText(node, `<${node.url}>`);
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-fenced-code-blocks.ts
+var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce the use of fenced code blocks over indented code blocks",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [],
+		messages: { useFencedCodeBlock: "Use a fenced code block instead of an indented code block." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const lines = parseLines(sourceCode);
+		return { code(node) {
+			const kind = getCodeBlockKind(sourceCode, node);
+			if (kind === "backtick-fenced" || kind === "tilde-fenced") return;
+			const loc = sourceCode.getLoc(node);
+			context.report({
+				node,
+				messageId: "useFencedCodeBlock",
+				fix(fixer) {
+					if (!isFixableIndentedCodeBlock(node)) return null;
+					const startColumnOffset = loc.start.column - 1;
+					const removeRanges = [];
+					let prefixText = null;
+					for (let line = loc.start.line; line <= loc.end.line; line++) {
+						const parsedLine = lines.get(line);
+						const currentPrefix = normalizePrefix(parsedLine.text.slice(0, startColumnOffset));
+						if (!prefixText) prefixText = currentPrefix;
+						else if (currentPrefix !== prefixText) return null;
+						let removeRange = [parsedLine.range[0] + startColumnOffset, parsedLine.range[0] + startColumnOffset + 4];
+						for (let index = removeRange[0]; index < removeRange[1]; index++) {
+							const c = sourceCode.text[index];
+							if (c === " ") continue;
+							if (c === "	") {
+								removeRange = [removeRange[0], index + 1];
+								break;
+							}
+							return null;
+						}
+						removeRanges.push(removeRange);
+					}
+					const beginFenceInsertOffset = lines.get(loc.start.line).range[0];
+					const endFenceInsertOffset = lines.get(loc.end.line).range[1];
+					return [
+						fixer.insertTextBeforeRange([beginFenceInsertOffset, beginFenceInsertOffset], `${prefixText}\`\`\`\n`),
+						...removeRanges.map((removeRange) => fixer.removeRange(removeRange)),
+						fixer.insertTextAfterRange([endFenceInsertOffset, endFenceInsertOffset], `${prefixText}\`\`\`\n`)
+					];
+				}
+			});
+		} };
+		/**
+		* Determines whether the given indented code block is fixable or not.
+		*/
+		function isFixableIndentedCodeBlock(node) {
+			if (!node.value.startsWith(" ")) return true;
+			const loc = sourceCode.getLoc(node);
+			const firstLine = lines.get(loc.start.line);
+			const codeBlockFirstLine = normalizePrefix(node.value.split(/\r?\n/u)[0]);
+			const startColumnOffset = loc.start.column - 1;
+			const normalizedFirstLine = normalizePrefix(firstLine.text.slice(startColumnOffset));
+			return normalizedFirstLine.startsWith(codeBlockFirstLine);
+		}
+	}
+});
+/**
+* Normalize the prefix by removing tabs and replacing them with spaces.
+*/
+function normalizePrefix(prefix) {
+	let result = "";
+	for (const c of prefix) if (c !== "	") result += c;
+	else result += " ".repeat(4 - result.length % 4);
+	return result;
+}
+
 //#endregion
 //#region src/utils/search-words.ts
 const RE_BOUNDARY = /^[\s\p{Letter_Number}\p{Modifier_Letter}\p{Modifier_Symbol}\p{Nonspacing_Mark}\p{Other_Letter}\p{Other_Symbol}\p{Script=Han}!"#$%&'()*+,./:;<=>?\\{|}~\u{2ffc}-\u{303d}\u{30a0}-\u{30fb}\u{3192}-\u{32bf}\u{fe10}-\u{fe1f}\u{fe30}-\u{fe6f}\u{ff00}-\u{ffef}\u{2ebf0}-\u{2ee5d}]*$/u;
@@ -1488,25 +1934,6 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 	}
 });
 
-//#endregion
-//#region src/utils/url.ts
-/**
-* Utility function to check if a string is a valid URL.
-*/
-function isValidURL(url) {
-	return Boolean(createURLSafe(url));
-}
-/**
-* Utility function to create a URL object safely.
-*/
-function createURLSafe(url) {
-	try {
-		return new URL(url);
-	} catch {
-		return null;
-	}
-}
-
 //#endregion
 //#region src/rules/prefer-linked-words.ts
 var prefer_linked_words_default = createRule("prefer-linked-words", {
@@ -1608,7 +2035,7 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 		* Adjust link to be relative to the file.
 		*/
 		function adjustLink(link) {
-			if (isValidURL(link)) return link;
+			if (URL.canParse(link)) return link;
 			if (link.startsWith("#")) return link;
 			const absoluteLink = path.isAbsolute(link) || path.posix.isAbsolute(link) ? link : path.join(context.cwd, link);
 			return `./${path.relative(path.dirname(context.filename), absoluteLink)}`;
@@ -1789,14 +2216,14 @@ var sort_definitions_default = createRule("sort-definitions", {
 		}
 		/** Compile order option */
 		function compileOption(orderOption) {
-			const cache = /* @__PURE__ */ new Map();
+			const cache$1 = /* @__PURE__ */ new Map();
 			const compiled = compileOptionWithoutCache(orderOption);
 			return {
 				match: (node) => {
-					const cached = cache.get(node);
+					const cached = cache$1.get(node);
 					if (cached != null) return cached;
 					const result = compiled.match(node);
-					cache.set(node, result);
+					cache$1.set(node, result);
 					return result;
 				},
 				sort: compiled.sort
@@ -1847,7 +2274,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 						if (node.label === patternStr || node.identifier === patternStr) return true;
 						if (node.type === "definition") {
 							if (node.url === patternStr) return true;
-							if (isValidURL(patternStr)) {
+							if (URL.canParse(patternStr) && URL.canParse(node.url)) {
 								const normalizedPattern = normalizedURL(patternStr);
 								const normalizedUrl = normalizedURL(node.url);
 								if (normalizedUrl.startsWith(normalizedPattern)) return true;
@@ -1894,7 +2321,7 @@ function getQuote(text) {
 * Normalize a URL by ensuring it ends with a slash.
 */
 function normalizedURL(url) {
-	const urlObj = createURLSafe(url);
+	const urlObj = new URL(url);
 	if (!urlObj) return url;
 	return urlObj.href.endsWith("/") ? urlObj.href : `${urlObj.href}/`;
 }
@@ -1906,8 +2333,12 @@ const rules$1 = [
 	definitions_last_default,
 	hard_linebreak_style_default,
 	heading_casing_default,
+	no_laziness_blockquotes_default,
+	no_multiple_empty_lines_default,
 	no_text_backslash_linebreak_default,
 	no_trailing_spaces_default,
+	prefer_autolinks_default,
+	prefer_fenced_code_blocks_default,
 	prefer_inline_code_words_default,
 	prefer_link_reference_definitions_default,
 	prefer_linked_words_default,
@@ -1920,13 +2351,15 @@ var recommended_exports = {};
 __export(recommended_exports, {
 	files: () => files,
 	language: () => language,
+	languageOptions: () => languageOptions,
 	name: () => name$1,
 	plugins: () => plugins,
 	rules: () => rules$2
 });
 const name$1 = "markdown-preferences/recommended";
 const files = ["*.md", "**/*.md"];
-const language = "markdown/commonmark";
+const language = "markdown/gfm";
+const languageOptions = { frontmatter: "yaml" };
 const plugins = {
 	markdown,
 	get "markdown-preferences"() {
@@ -1935,7 +2368,10 @@ const plugins = {
 };
 const rules$2 = {
 	"markdown-preferences/hard-linebreak-style": "error",
-	"markdown-preferences/no-text-backslash-linebreak": "error"
+	"markdown-preferences/no-laziness-blockquotes": "error",
+	"markdown-preferences/no-text-backslash-linebreak": "error",
+	"markdown-preferences/prefer-autolinks": "error",
+	"markdown-preferences/prefer-fenced-code-blocks": "error"
 };
 
 //#endregion
@@ -1946,7 +2382,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.9.0";
+const version = "0.11.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

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