eslint-plugin-markdown-preferences 0.7.0 → 0.8.0

package/README.md

@@ -13,10 +13,10 @@ A specialized ESLint plugin that helps enforce consistent writing style and form
 
 ## 📛 Features
 
-- **🔧 Auto-fixable rules** - Automatically format your Markdown files to match your style preferences
-- **📝 Line break consistency** - Enforce consistent hard line break styles (backslash `\` vs trailing spaces)
-- **🔗 Link enforcement** - Ensure specific words or terms are properly linked to their documentation
-- **🎯 Customizable** - Configure rules to match your team's specific requirements
+- **⚡ Effortless automation** - Transform your Markdown with auto-fixing that handles formatting, linking, and style consistency automatically
+- **📖 Professional documentation** - Enforce consistent line breaks, clean up trailing spaces, and organize link definitions for enterprise-ready documentation
+- **🎯 Smart terminology management** - Automatically convert specified words into inline code or clickable links based on your configuration
+- **⚙️ Highly customizable configuration** - Fine-tune every aspect with granular rule options, word lists, ignore patterns, and flexible thresholds to match your exact requirements
 
 **Try it live:** Check out the [Online Demo](https://eslint-online-playground.netlify.app/#eslint-plugin-markdown-preferences) to see the plugin in action!
 
@@ -86,17 +86,23 @@ The rules with the following star ⭐ are included in the configs.
 
 <!--RULES_TABLE_START-->
 
-### Markdown Rules
+### Preference Rules
+
+| Rule ID | Description | Fixable | RECOMMENDED |
+|:--------|:------------|:-------:|:-----------:|
+| [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. | 🔧 |  |
+
+### Stylistic Rules
 
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
 | [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/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/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-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-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/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. | 🔧 |  |
+| [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 | 🔧 |  |
 
 <!--RULES_TABLE_END-->
 <!--RULES_SECTION_END-->

package/lib/index.d.ts

@@ -45,6 +45,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html
    */
   'markdown-preferences/prefer-linked-words'?: Linter.RuleEntry<MarkdownPreferencesPreferLinkedWords>;
+  /**
+   * enforce a specific order for link definitions and footnote definitions
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html
+   */
+  'markdown-preferences/sort-definitions'?: Linter.RuleEntry<MarkdownPreferencesSortDefinitions>;
 }
 type MarkdownPreferencesHardLinebreakStyle = [] | [{
   style?: ("backslash" | "spaces");
@@ -80,6 +85,13 @@ type MarkdownPreferencesPreferLinkedWords = [] | [{
   }[];
   [k: string]: unknown | undefined;
 }];
+type MarkdownPreferencesSortDefinitions = [] | [{
+  order?: (string | [string, ...(string)[]] | {
+    match: (string | [string, ...(string)[]]);
+    sort: ("alphabetical" | "ignore");
+  })[];
+  alphabetical?: boolean;
+}];
 declare namespace recommended_d_exports {
   export { files, language, name$1 as name, plugins, rules$1 as rules };
 }
@@ -95,7 +107,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.7.0";
+declare const version: "0.8.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -32,7 +32,8 @@ var definitions_last_default = createRule("definitions-last", {
 		type: "layout",
 		docs: {
 			description: "require link definitions and footnote definitions to be placed at the end of the document",
-			categories: []
+			categories: [],
+			listCategory: "Stylistic"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -72,7 +73,8 @@ var hard_linebreak_style_default = createRule("hard-linebreak-style", {
 		type: "layout",
 		docs: {
 			description: "enforce consistent hard linebreak style.",
-			categories: ["recommended"]
+			categories: ["recommended"],
+			listCategory: "Stylistic"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -116,7 +118,8 @@ var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebrea
 		type: "suggestion",
 		docs: {
 			description: "disallow text backslash at the end of a line.",
-			categories: ["recommended"]
+			categories: ["recommended"],
+			listCategory: "Preference"
 		},
 		fixable: void 0,
 		hasSuggestions: true,
@@ -172,7 +175,8 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 		type: "layout",
 		docs: {
 			description: "disallow trailing whitespace at the end of lines in Markdown files.",
-			categories: []
+			categories: [],
+			listCategory: "Stylistic"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -380,7 +384,8 @@ var prefer_inline_code_words_default = createRule("prefer-inline-code-words", {
 		type: "suggestion",
 		docs: {
 			description: "enforce the use of inline code for specific words.",
-			categories: []
+			categories: [],
+			listCategory: "Preference"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -450,7 +455,8 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 		type: "layout",
 		docs: {
 			description: "enforce using link reference definitions instead of inline links",
-			categories: []
+			categories: [],
+			listCategory: "Stylistic"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -472,7 +478,7 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 		const minLinks = options.minLinks ?? 2;
 		const definitions = [];
 		const links = [];
-		const linkReferences = [];
+		const references = [];
 		const headings = [];
 		/**
 		* Verify links.
@@ -480,13 +486,13 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 		function verify() {
 			const resourceToNodes = /* @__PURE__ */ new Map();
 			for (const link of links) getResourceNodes(link).links.push(link);
-			for (const linkReference of linkReferences) {
-				const definition = definitions.find((def) => def.identifier === linkReference.identifier);
-				if (definition) getResourceNodes(definition).linkReferences.push(linkReference);
+			for (const reference of references) {
+				const definition = definitions.find((def) => def.identifier === reference.identifier);
+				if (definition) getResourceNodes(definition).references.push(reference);
 			}
 			for (const definition of definitions) getResourceNodes(definition).definitions.push(definition);
 			for (const map of resourceToNodes.values()) for (const nodes of map.values()) {
-				if (nodes.links.length === 0 || nodes.links.length + nodes.linkReferences.length < minLinks) continue;
+				if (nodes.links.length === 0 || nodes.links.length + nodes.references.length < minLinks) continue;
 				for (const link of nodes.links) {
 					const linkInfo = getLinkInfo(link);
 					if (linkInfo.label === "") continue;
@@ -497,8 +503,16 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 							const definition = nodes.definitions[0];
 							let identifier;
 							if (definition) identifier = definition.label ?? definition.identifier;
-							else identifier = linkInfo.label.replaceAll(/[[\]]/gu, "-");
-							yield fixer.replaceText(link, `${sourceCode.text.slice(...linkInfo.labelRange)}${identifier === linkInfo.label ? "" : `[${identifier}]`}`);
+							else {
+								identifier = linkInfo.label.replaceAll(/[[\]]/gu, "-");
+								if (definitions.some((def) => def.identifier === identifier)) {
+									let seq = 1;
+									const original = identifier;
+									identifier = `${original}-${seq}`;
+									while (definitions.some((def) => def.identifier === identifier)) identifier = `${original}-${++seq}`;
+								}
+							}
+							yield fixer.replaceText(link, `${sourceCode.text.slice(...linkInfo.bracketsRange)}${identifier === linkInfo.label ? "" : `[${identifier}]`}`);
 							if (!definition) {
 								const linkRange = sourceCode.getRange(link);
 								const nextSectionHeading = headings.find((heading) => linkRange[1] < sourceCode.getRange(heading)[0]);
@@ -529,7 +543,7 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 				if (!nodes) {
 					nodes = {
 						links: [],
-						linkReferences: [],
+						references: [],
 						definitions: []
 					};
 					map.set(title, nodes);
@@ -539,10 +553,13 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 		}
 		return {
 			link(node) {
+				if (sourceCode.getText(node).startsWith("[")) links.push(node);
+			},
+			image(node) {
 				links.push(node);
 			},
-			linkReference(node) {
-				linkReferences.push(node);
+			"linkReference, imageReference"(node) {
+				references.push(node);
 			},
 			definition(node) {
 				definitions.push(node);
@@ -559,31 +576,70 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 		*/
 		function getLinkInfo(link) {
 			const range = sourceCode.getRange(link);
-			const linkLabelRange = getLinkLabelRange();
-			const linkLabelWithBracketsText = sourceCode.text.slice(...linkLabelRange);
-			const linkLabelText = linkLabelWithBracketsText.slice(1, -1).trim();
-			const urlStartIndex = sourceCode.text.indexOf("(", linkLabelRange[1]);
+			if (link.type === "link") {
+				const bracketsRange$1 = getLinkBracketsRange(link);
+				const linkBracketsText$1 = sourceCode.text.slice(...bracketsRange$1);
+				const linkLabelText$1 = linkBracketsText$1.slice(1, -1).trim();
+				const urlStartIndex$1 = sourceCode.text.indexOf("(", bracketsRange$1[1]);
+				return {
+					label: linkLabelText$1,
+					bracketsRange: bracketsRange$1,
+					urlAndTitleRange: [urlStartIndex$1, range[1]]
+				};
+			}
+			const bracketsRange = getImageBracketsRange(link);
+			const linkBracketsText = sourceCode.text.slice(...bracketsRange);
+			const linkLabelText = linkBracketsText.slice(1, -1).trim();
+			const urlStartIndex = sourceCode.text.indexOf("(", bracketsRange[1]);
 			return {
 				label: linkLabelText,
-				labelRange: linkLabelRange,
+				bracketsRange,
 				urlAndTitleRange: [urlStartIndex, range[1]]
 			};
-			/**
-			* Get the range of the link label.
-			*/
-			function getLinkLabelRange() {
-				if (link.children.length === 0) {
-					const index$1 = sourceCode.text.indexOf("]", range[0] + 1);
-					return [range[0], index$1 + 1];
-				}
-				const lastRange = sourceCode.getRange(link.children[link.children.length - 1]);
-				const index = sourceCode.text.indexOf("]", lastRange[1]);
-				return [range[0], index + 1];
+		}
+		/**
+		* Get the range of the link label.
+		*/
+		function getLinkBracketsRange(link) {
+			const range = sourceCode.getRange(link);
+			if (link.children.length === 0) {
+				const index$1 = sourceCode.text.indexOf("]", range[0] + 1);
+				return [range[0], index$1 + 1];
 			}
+			const lastRange = sourceCode.getRange(link.children[link.children.length - 1]);
+			const index = sourceCode.text.indexOf("]", lastRange[1]);
+			return [range[0], index + 1];
+		}
+		/**
+		* Get the range of the image label.
+		*/
+		function getImageBracketsRange(image) {
+			const range = sourceCode.getRange(image);
+			const index = sourceCode.text.indexOf("]", range[0] + 2);
+			return [range[0] + 1, index + 1];
 		}
 	}
 });
 
+//#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", {
@@ -591,7 +647,8 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 		type: "suggestion",
 		docs: {
 			description: "enforce the specified word to be a link.",
-			categories: []
+			categories: [],
+			listCategory: "Preference"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -684,7 +741,7 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 		* Adjust link to be relative to the file.
 		*/
 		function adjustLink(link) {
-			if (/^\w+:/.test(link)) return link;
+			if (isValidURL(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)}`;
@@ -692,6 +749,314 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 	}
 });
 
+//#endregion
+//#region src/utils/regexp.ts
+const RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u;
+/**
+* Convert a string to the `RegExp`.
+* Normal strings (e.g. `"foo"`) is converted to `/^foo$/` of `RegExp`.
+* Strings like `"/^foo/i"` are converted to `/^foo/i` of `RegExp`.
+*
+* @param {string} string The string to convert.
+* @returns {RegExp} Returns the `RegExp`.
+*/
+function toRegExp(string) {
+	const parts = RE_REGEXP_STR.exec(string);
+	if (parts) return new RegExp(parts[1], parts[2]);
+	return { test: (s) => s === string };
+}
+/**
+* Checks whether given string is regexp string
+* @param {string} string
+* @returns {boolean}
+*/
+function isRegExp(string) {
+	return Boolean(RE_REGEXP_STR.test(string));
+}
+
+//#endregion
+//#region src/rules/sort-definitions.ts
+var sort_definitions_default = createRule("sort-definitions", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce a specific order for link definitions and footnote definitions",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				order: {
+					type: "array",
+					items: { anyOf: [
+						{ type: "string" },
+						{
+							type: "array",
+							items: { type: "string" },
+							uniqueItems: true,
+							minItems: 1
+						},
+						{
+							type: "object",
+							properties: {
+								match: { anyOf: [{ type: "string" }, {
+									type: "array",
+									items: { type: "string" },
+									uniqueItems: true,
+									minItems: 1
+								}] },
+								sort: { enum: ["alphabetical", "ignore"] }
+							},
+							required: ["match", "sort"],
+							additionalProperties: false
+						}
+					] },
+					uniqueItems: true,
+					additionalItems: false
+				},
+				alphabetical: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: { shouldBefore: "The definition '{{currentKey}}' should be before '{{prevKey}}'." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = parseOption(context.options[0]);
+		const group = [];
+		const cacheText = /* @__PURE__ */ new Map();
+		/** Get normalized text */
+		function getDefinitionText(node) {
+			const k = cacheText.get(node);
+			if (k != null) return k;
+			if (node.type === "definition") return `[${node.label || node.identifier}]: ${node.url}${printTitle(node.title)}`;
+			let childrenText = "";
+			if (node.children.length) {
+				const [start] = sourceCode.getRange(node.children[0]);
+				const [, end] = sourceCode.getRange(node.children.at(-1));
+				childrenText = sourceCode.text.slice(start, end);
+			}
+			return `[^${node.identifier}]: ${childrenText}`;
+		}
+		/** Report */
+		function report(node, previousNode, definitions) {
+			const currentKey = getDefinitionText(node);
+			const prevKey = getDefinitionText(previousNode);
+			context.report({
+				node,
+				messageId: "shouldBefore",
+				data: {
+					currentKey,
+					prevKey
+				},
+				fix(fixer) {
+					const previousNodeIndex = definitions.indexOf(previousNode);
+					const targetNodeIndex = definitions.indexOf(node);
+					const previousNodes = definitions.slice(previousNodeIndex, targetNodeIndex);
+					const before = definitions.slice(0, previousNodeIndex);
+					const after = definitions.slice(targetNodeIndex + 1);
+					const movedNodes = [
+						...before,
+						node,
+						...previousNodes,
+						...after
+					];
+					return movedNodes.map((moveNode, index) => {
+						let text = sourceCode.getText(moveNode);
+						if (moveNode.type === "definition" && index > 0) {
+							if (movedNodes[index - 1].type === "footnoteDefinition") {
+								const footnoteLoc = sourceCode.getLoc(definitions[index - 1]);
+								const linkLoc = sourceCode.getLoc(definitions[index]);
+								if (linkLoc.start.line - footnoteLoc.end.line <= 1) text = `\n${text}`;
+							}
+						}
+						return fixer.replaceText(definitions[index], text);
+					});
+				}
+			});
+		}
+		/**
+		* Verify definitions and footnote definitions.
+		*/
+		function verify(definitions) {
+			if (definitions.length === 0) return;
+			const validPreviousNodes = [];
+			for (const definition of definitions) {
+				if (option.ignore(definition)) continue;
+				const invalidPreviousNode = validPreviousNodes.find((previousNode) => option.compare(previousNode, definition) > 0);
+				if (invalidPreviousNode) {
+					report(definition, invalidPreviousNode, definitions);
+					continue;
+				}
+				validPreviousNodes.push(definition);
+			}
+		}
+		return {
+			"*"(node) {
+				const last = group.at(-1);
+				if (last && (node.type !== "definition" && node.type !== "footnoteDefinition" || sourceCode.getParent(node) !== sourceCode.getParent(last))) {
+					const range = sourceCode.getRange(node);
+					const lastDefinitionRange = sourceCode.getRange(node);
+					if (lastDefinitionRange[1] <= range[0]) {
+						verify(group);
+						group.length = 0;
+					}
+				}
+				if (node.type === "definition" || node.type === "footnoteDefinition") group.push(node);
+			},
+			"root:exit"() {
+				verify(group);
+			}
+		};
+		/** Parse options */
+		function parseOption(userOption) {
+			const order = userOption?.order ?? [{
+				match: String.raw`!/^\[\\^/u`,
+				sort: "alphabetical"
+			}, {
+				match: String.raw`/./u`,
+				sort: "alphabetical"
+			}];
+			const compiled = order.map(compileOption);
+			return {
+				ignore: (node) => {
+					return !compiled.some((c) => c.match(node));
+				},
+				compare: (a, b) => {
+					for (const c of compiled) {
+						const matchA = c.match(a);
+						const matchB = c.match(b);
+						if (matchA && matchB) {
+							if (c.sort === "alphabetical") {
+								const textA = getDefinitionText(a);
+								const textB = getDefinitionText(b);
+								if (textA === textB) return 0;
+								return textA < textB ? -1 : 1;
+							}
+							return 0;
+						}
+						if (matchA) return -1;
+						if (matchB) return 1;
+					}
+					throw new Error("Illegal state");
+				}
+			};
+		}
+		/** Compile order option */
+		function compileOption(orderOption) {
+			const cache = /* @__PURE__ */ new Map();
+			const compiled = compileOptionWithoutCache(orderOption);
+			return {
+				match: (node) => {
+					const cached = cache.get(node);
+					if (cached != null) return cached;
+					const result = compiled.match(node);
+					cache.set(node, result);
+					return result;
+				},
+				sort: compiled.sort
+			};
+		}
+		/** Compile order option without cache */
+		function compileOptionWithoutCache(orderOption) {
+			if (typeof orderOption === "string") {
+				const match$1 = compileMatcher([orderOption]);
+				return {
+					match: match$1,
+					sort: "ignore"
+				};
+			}
+			if (Array.isArray(orderOption)) {
+				const match$1 = compileMatcher(orderOption);
+				return {
+					match: match$1,
+					sort: "ignore"
+				};
+			}
+			const { match } = compileOptionWithoutCache(orderOption.match);
+			return {
+				match,
+				sort: orderOption.sort || "ignore"
+			};
+		}
+		/** Compile matcher */
+		function compileMatcher(pattern) {
+			const rules$3 = [];
+			for (const p of pattern) {
+				let negative, patternStr;
+				if (p.startsWith("!")) {
+					negative = true;
+					patternStr = p.substring(1);
+				} else {
+					negative = false;
+					patternStr = p;
+				}
+				const regex = toRegExp(patternStr);
+				if (isRegExp(patternStr)) rules$3.push({
+					negative,
+					match: (node) => regex.test(getDefinitionText(node))
+				});
+				else rules$3.push({
+					negative,
+					match: (node) => {
+						if (node.label === patternStr || node.identifier === patternStr) return true;
+						if (node.type === "definition") {
+							if (node.url === patternStr) return true;
+							if (isValidURL(patternStr)) {
+								const normalizedPattern = normalizedURL(patternStr);
+								const normalizedUrl = normalizedURL(node.url);
+								if (normalizedUrl.startsWith(normalizedPattern)) return true;
+							}
+						}
+						return regex.test(getDefinitionText(node));
+					}
+				});
+			}
+			return (node) => {
+				let result = Boolean(rules$3[0]?.negative);
+				for (const { negative, match } of rules$3) {
+					if (result === !negative) continue;
+					if (match(node)) result = !negative;
+				}
+				return result;
+			};
+		}
+	}
+});
+/**
+* Print the title with quotes.
+*/
+function printTitle(title) {
+	if (!title) return "";
+	let titleToPrint = title.replaceAll(/\\(?=["')])/gu, "");
+	if (titleToPrint.includes("\"") && titleToPrint.includes("'") && !titleToPrint.includes(")")) return ` (${titleToPrint})`;
+	const quote = getQuote(titleToPrint);
+	titleToPrint = titleToPrint.replaceAll("\\", "\\\\");
+	titleToPrint = titleToPrint.replaceAll(quote, `\\${quote}`);
+	return ` ${quote}${titleToPrint}${quote}`;
+}
+/**
+* Get the preferred quote for a string.
+*/
+function getQuote(text) {
+	let doubleQuoteCount = 0;
+	let singleQuoteCount = 0;
+	for (const character of text) if (character === "\"") doubleQuoteCount++;
+	else if (character === "'") singleQuoteCount++;
+	return doubleQuoteCount > singleQuoteCount ? "'" : "\"";
+}
+/**
+* Normalize a URL by ensuring it ends with a slash.
+*/
+function normalizedURL(url) {
+	const urlObj = createURLSafe(url);
+	if (!urlObj) return url;
+	return urlObj.href.endsWith("/") ? urlObj.href : `${urlObj.href}/`;
+}
+
 //#endregion
 //#region src/utils/rules.ts
 const rules$1 = [
@@ -701,7 +1066,8 @@ const rules$1 = [
 	no_trailing_spaces_default,
 	prefer_inline_code_words_default,
 	prefer_link_reference_definitions_default,
-	prefer_linked_words_default
+	prefer_linked_words_default,
+	sort_definitions_default
 ];
 
 //#endregion
@@ -736,7 +1102,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.7.0";
+const version = "0.8.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

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