eslint-plugin-markdown-preferences 0.8.0 → 0.9.0

package/README.md

@@ -28,7 +28,7 @@ For detailed usage instructions, rule configurations, and examples, visit our co
 
 ## 💿 Installation
 
-```bash
+```sh
 npm install --save-dev eslint eslint-plugin-markdown-preferences
 ```
 
@@ -98,8 +98,10 @@ 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-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-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 | 🔧 |  |

package/lib/index.d.ts

@@ -10,6 +10,11 @@ declare module 'eslint' {
   }
 }
 interface RuleOptions {
+  /**
+   * enforce canonical language names in code blocks
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html
+   */
+  'markdown-preferences/canonical-code-block-language'?: Linter.RuleEntry<MarkdownPreferencesCanonicalCodeBlockLanguage>;
   /**
    * require link definitions and footnote definitions to be placed at the end of the document
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html
@@ -20,6 +25,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html
    */
   'markdown-preferences/hard-linebreak-style'?: Linter.RuleEntry<MarkdownPreferencesHardLinebreakStyle>;
+  /**
+   * enforce consistent casing in headings.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html
+   */
+  'markdown-preferences/heading-casing'?: Linter.RuleEntry<MarkdownPreferencesHeadingCasing>;
   /**
    * 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
@@ -51,9 +61,20 @@ interface RuleOptions {
    */
   'markdown-preferences/sort-definitions'?: Linter.RuleEntry<MarkdownPreferencesSortDefinitions>;
 }
+type MarkdownPreferencesCanonicalCodeBlockLanguage = [] | [{
+  languages?: {
+    [k: string]: string;
+  };
+}];
 type MarkdownPreferencesHardLinebreakStyle = [] | [{
   style?: ("backslash" | "spaces");
 }];
+type MarkdownPreferencesHeadingCasing = [] | [{
+  style?: ("Title Case" | "Sentence case");
+  preserveWords?: string[];
+  ignorePatterns?: string[];
+  minorWords?: string[];
+}];
 type MarkdownPreferencesNoTrailingSpaces = [] | [{
   skipBlankLines?: boolean;
   ignoreComments?: boolean;
@@ -107,19 +128,27 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.8.0";
+declare const version: "0.9.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {
   recommended: typeof recommended_d_exports;
 };
 declare const rules: Record<string, RuleDefinition>;
+declare const resources: {
+  defaultPreserveWords: string[];
+  defaultMinorWords: string[];
+};
 declare const _default: {
   meta: typeof meta_d_exports;
   configs: {
     recommended: typeof recommended_d_exports;
   };
   rules: Record<string, RuleDefinition<_eslint_core0.RuleDefinitionTypeOptions>>;
+  resources: {
+    defaultPreserveWords: string[];
+    defaultMinorWords: string[];
+  };
 };
 //#endregion
-export { RuleOptions, configs, _default as default, meta_d_exports as meta, rules };
+export { RuleOptions, configs, _default as default, meta_d_exports as meta, resources, rules };

package/lib/index.js

@@ -25,6 +25,98 @@ function createRule(ruleName, rule) {
 	};
 }
 
+//#endregion
+//#region src/rules/canonical-code-block-language.ts
+const DEFAULT_LANGUAGES = {
+	javascript: "js",
+	jsx: "js",
+	mjs: "js",
+	cjs: "js",
+	typescript: "ts",
+	tsx: "ts",
+	mts: "ts",
+	cts: "ts",
+	python: "py",
+	bash: "sh",
+	shell: "sh",
+	zsh: "sh",
+	yml: "yaml",
+	markdown: "md",
+	rust: "rs",
+	golang: "go",
+	cplusplus: "cpp",
+	"c++": "cpp",
+	postgresql: "sql",
+	mysql: "sql",
+	sqlite: "sql"
+};
+var canonical_code_block_language_default = createRule("canonical-code-block-language", {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "enforce canonical language names in code blocks",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { languages: {
+				type: "object",
+				patternProperties: { "^[\\s\\S]+$": { type: "string" } },
+				additionalProperties: false
+			} },
+			additionalProperties: false
+		}],
+		messages: { useCanonical: "Use canonical language name \"{{canonical}}\" instead of \"{{current}}\"." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const languages = context.options[0]?.languages || DEFAULT_LANGUAGES;
+		return { code(node) {
+			if (!node.lang || !languages[node.lang]) return;
+			const canonical = languages[node.lang];
+			const current = node.lang;
+			if (current === canonical) return;
+			const nodeRange = sourceCode.getRange(node);
+			const nodeText = sourceCode.text.slice(nodeRange[0], nodeRange[1]);
+			const fenceRegex = /^(`{3,}|~{3,})(\w*)(?:\s.*)?$/mu;
+			const fenceMatch = fenceRegex.exec(nodeText.split("\n")[0]);
+			if (!fenceMatch) return;
+			const [, fence, langInfo] = fenceMatch;
+			const langStart = nodeRange[0] + fence.length;
+			const langEnd = langStart + langInfo.length;
+			const nodeLoc = sourceCode.getLoc(node);
+			const beforeFence = sourceCode.text.slice(nodeRange[0], langStart);
+			const beforeLines = beforeFence.split(/\n/u);
+			const line = nodeLoc.start.line + beforeLines.length - 1;
+			const column = (beforeLines.length === 1 ? nodeLoc.start.column : 0) + (beforeLines.at(-1) || "").length;
+			context.report({
+				node,
+				loc: {
+					start: {
+						line,
+						column
+					},
+					end: {
+						line,
+						column: column + langInfo.length
+					}
+				},
+				messageId: "useCanonical",
+				data: {
+					canonical,
+					current
+				},
+				fix(fixer) {
+					return fixer.replaceTextRange([langStart, langEnd], canonical);
+				}
+			});
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/definitions-last.ts
 var definitions_last_default = createRule("definitions-last", {
@@ -111,6 +203,781 @@ var hard_linebreak_style_default = createRule("hard-linebreak-style", {
 	}
 });
 
+//#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/resources/preserve-words.ts
+const defaultPreserveWords = [
+	"JavaScript",
+	"TypeScript",
+	"ECMAScript",
+	"ES6",
+	...(function* () {
+		const end = (/* @__PURE__ */ new Date()).getFullYear() + 3;
+		for (let i = 2015; i <= end; i++) yield `ES${i}`;
+	})(),
+	"PHP",
+	"Python",
+	"Java",
+	"C#",
+	"C++",
+	"Rust",
+	"Go",
+	"go",
+	"Swift",
+	"Kotlin",
+	"Dart",
+	"Ruby",
+	"Scala",
+	"Perl",
+	"R",
+	"MATLAB",
+	"Lua",
+	"Haskell",
+	"Elixir",
+	"Clojure",
+	"F#",
+	"OCaml",
+	"Zig",
+	"V",
+	"Nim",
+	"Crystal",
+	"Gleam",
+	"Odin",
+	"Carbon",
+	"HTML",
+	"CSS",
+	"Sass",
+	"SCSS",
+	"Less",
+	"Stylus",
+	"JSON",
+	"XML",
+	"PDF",
+	"CSV",
+	"YAML",
+	"TOML",
+	"Markdown",
+	"LaTeX",
+	"Parquet",
+	"Avro",
+	"Protobuf",
+	"MessagePack",
+	"BSON",
+	"HDF5",
+	"Apache Arrow",
+	"ORC",
+	"SQL",
+	"GraphQL",
+	"React",
+	"Vue",
+	"Angular",
+	"Redux",
+	"Svelte",
+	"SvelteKit",
+	"Preact",
+	"Solid",
+	"Alpine.js",
+	"Lit",
+	"Stencil",
+	"Ember.js",
+	"Backbone.js",
+	"jQuery",
+	"D3.js",
+	"Three.js",
+	"Chart.js",
+	"Plotly",
+	"Astro",
+	"Remix",
+	"Qwik",
+	"SolidJS",
+	"Vike",
+	"Node.js",
+	"Deno",
+	"Bun",
+	"Electron",
+	"Tauri",
+	"Next.js",
+	"Nuxt.js",
+	"Gatsby",
+	"Express.js",
+	"NestJS",
+	"FastAPI",
+	"Django",
+	"Flask",
+	"Ruby on Rails",
+	"Spring Boot",
+	"Laravel",
+	"Phoenix",
+	"Actix",
+	"Axum",
+	"Rocket",
+	"Flutter",
+	"React Native",
+	"Ionic",
+	"Xamarin",
+	"Expo",
+	"Unity",
+	"Unreal Engine",
+	"ESLint",
+	"Prettier",
+	"Biome",
+	"oxc",
+	"swc",
+	"Webpack",
+	"Vite",
+	"Babel",
+	"Workbox",
+	"Rollup",
+	"Parcel",
+	"esbuild",
+	"Turbo",
+	"Turborepo",
+	"Nx",
+	"Lerna",
+	"Rush",
+	"npm",
+	"yarn",
+	"pnpm",
+	"bun",
+	"bower",
+	"composer",
+	"pip",
+	"conda",
+	"Maven",
+	"Gradle",
+	"SBT",
+	"Cargo",
+	"homebrew",
+	"chocolatey",
+	"CocoaPods",
+	"Carthage",
+	"Swift Package Manager",
+	"VS Code",
+	"Visual Studio Code",
+	"Vim",
+	"Neovim",
+	"Emacs",
+	"Sublime Text",
+	"Atom",
+	"Brackets",
+	"brackets",
+	"Visual Studio",
+	"IntelliJ IDEA",
+	"WebStorm",
+	"PHPStorm",
+	"PyCharm",
+	"Android Studio",
+	"Xcode",
+	"Docker",
+	"Kubernetes",
+	"Helm",
+	"CI / CD",
+	"DevOps",
+	"GitOps",
+	"IaC",
+	"Infrastructure as Code",
+	"SaaS",
+	"PaaS",
+	"IaaS",
+	"CDN",
+	"Load Balancer",
+	"API Gateway",
+	"Microservices",
+	"Serverless",
+	"Lambda",
+	"Cloud Functions",
+	"Container Registry",
+	"Prometheus",
+	"Grafana",
+	"Terraform",
+	"Ansible",
+	"Jenkins",
+	"GitHub Actions",
+	"GitLab CI",
+	"CircleCI",
+	"Travis CI",
+	"Azure DevOps",
+	"TeamCity",
+	"Bamboo",
+	"Buildkite",
+	"Drone CI",
+	"AWS",
+	"Amazon Web Services",
+	"Azure",
+	"GCP",
+	"Google Cloud Platform",
+	"Heroku",
+	"Vercel",
+	"Netlify",
+	"Railway",
+	"Render",
+	"Fly.io",
+	"Cloudflare",
+	"DigitalOcean",
+	"API",
+	"APIs",
+	"REST",
+	"RESTful",
+	"gRPC",
+	"HTTP",
+	"HTTPS",
+	"WebSocket",
+	"SOAP",
+	"XML-RPC",
+	"JSON-RPC",
+	"CLI",
+	"SDK",
+	"URL",
+	"URI",
+	"UUID",
+	"GUID",
+	"CRUD",
+	"ACID",
+	"BASE",
+	"CAP Theorem",
+	"JWT",
+	"OAuth",
+	"OAuth2",
+	"OpenID Connect",
+	"SAML",
+	"SSO",
+	"MFA",
+	"2FA",
+	"CORS",
+	"CSRF",
+	"XSS",
+	"SSH",
+	"FTP",
+	"SFTP",
+	"SMTP",
+	"IMAP",
+	"POP3",
+	"TCP",
+	"UDP",
+	"IP",
+	"IPv4",
+	"IPv6",
+	"DNS",
+	"DHCP",
+	"VPN",
+	"SSL",
+	"TLS",
+	"LDAP",
+	"PostgreSQL",
+	"MySQL",
+	"SQLite",
+	"MariaDB",
+	"Oracle",
+	"SQL Server",
+	"CockroachDB",
+	"PlanetScale",
+	"Neon",
+	"NoSQL",
+	"MongoDB",
+	"DynamoDB",
+	"Cassandra",
+	"CouchDB",
+	"Neo4j",
+	"ArangoDB",
+	"FaunaDB",
+	"Firebase",
+	"Supabase",
+	"Redis",
+	"ElasticSearch",
+	"Solr",
+	"InfluxDB",
+	"TimescaleDB",
+	"Prisma",
+	"TypeORM",
+	"Sequelize",
+	"Mongoose",
+	"Drizzle",
+	"Knex.js",
+	"Objection.js",
+	"Bookshelf.js",
+	"QA",
+	"QC",
+	"TDD",
+	"BDD",
+	"E2E",
+	"Unit Testing",
+	"Integration Testing",
+	"Jest",
+	"Mocha",
+	"Chai",
+	"Jasmine",
+	"Karma",
+	"Vitest",
+	"Ava",
+	"Tape",
+	"Cypress",
+	"Playwright",
+	"Selenium",
+	"Puppeteer",
+	"WebDriver",
+	"TestCafe",
+	"SonarQube",
+	"Husky",
+	"lint-staged",
+	"commitizen",
+	"semantic-release",
+	"Codecov",
+	"CodeClimate",
+	"TensorFlow",
+	"PyTorch",
+	"Keras",
+	"Scikit-learn",
+	"Pandas",
+	"NumPy",
+	"OpenCV",
+	"Hugging Face",
+	"LangChain",
+	"OpenAI",
+	"Anthropic",
+	"Jupyter",
+	"MLflow",
+	"Weights & Biases",
+	"CUDA",
+	"ONNX",
+	"GPT",
+	"BERT",
+	"Transformer",
+	"Claude",
+	"Gemini",
+	"LLaMA",
+	"Stable Diffusion",
+	"DALL-E",
+	"Midjourney",
+	"AutoML",
+	"ETL",
+	"ELT",
+	"Big Data",
+	"Data Lake",
+	"Data Warehouse",
+	"OLAP",
+	"OLTP",
+	"Apache Spark",
+	"Apache Kafka",
+	"Apache Airflow",
+	"Hadoop",
+	"Snowflake",
+	"Databricks",
+	"Tableau",
+	"Power BI",
+	"Looker",
+	"OWASP",
+	"SAST",
+	"DAST",
+	"IAST",
+	"SCA",
+	"Penetration Testing",
+	"Vulnerability Assessment",
+	"RBAC",
+	"ABAC",
+	"Zero Trust",
+	"PKI",
+	"HSM",
+	"WAF",
+	"DDoS",
+	"PWA",
+	"SPA",
+	"SSR",
+	"SSG",
+	"CSR",
+	"JAMstack",
+	"Headless CMS",
+	"Edge Computing",
+	"WebAssembly",
+	"WASM",
+	"Service Worker",
+	"Web Components",
+	"Micro Frontends",
+	"BFF",
+	"Backend for Frontend",
+	"GraphQL",
+	"tRPC",
+	"gRPC-Web",
+	"WebRTC",
+	"WebGL",
+	"WebGPU",
+	"Material UI",
+	"Ant Design",
+	"Chakra UI",
+	"React Bootstrap",
+	"Semantic UI React",
+	"Blueprint",
+	"Mantine",
+	"NextUI",
+	"Arco Design",
+	"Tailwind CSS",
+	"Bootstrap",
+	"Bulma",
+	"Foundation",
+	"Semantic UI",
+	"Materialize",
+	"Spectre.css",
+	"Tachyons",
+	"PureCSS",
+	"styled-components",
+	"CSS-in-JS",
+	"Emotion",
+	"JSS",
+	"Styled System",
+	"Stitches",
+	"Vanilla Extract",
+	"Linaria",
+	"Aphrodite",
+	"Glamorous",
+	"Radium",
+	"Git",
+	"Mercurial",
+	"SVN",
+	"GitHub",
+	"GitLab",
+	"Bitbucket",
+	"Pull Request",
+	"Merge Request",
+	"Code Review",
+	"Pair Programming",
+	"Mob Programming",
+	"Docusaurus",
+	"GitBook",
+	"VitePress",
+	"VuePress",
+	"Docsify",
+	"MkDocs",
+	"Sphinx",
+	"Jekyll",
+	"Hugo",
+	"Eleventy",
+	"Hexo",
+	"Zola",
+	"Swagger",
+	"OpenAPI",
+	"Postman",
+	"Insomnia",
+	"Redoc",
+	"Stoplight",
+	"FAQ"
+];
+
+//#endregion
+//#region src/resources/minor-words.ts
+const articles = [
+	"a",
+	"an",
+	"the"
+];
+const conjunctions = [
+	"for",
+	"and",
+	"nor",
+	"but",
+	"or",
+	"yet",
+	"so"
+];
+const prepositions = [
+	"a",
+	"as",
+	"at",
+	"by",
+	"ex",
+	"in",
+	"of",
+	"on",
+	"re",
+	"to",
+	"up"
+];
+const defaultMinorWords = [
+	...articles,
+	...conjunctions,
+	...prepositions
+];
+
+//#endregion
+//#region src/rules/heading-casing.ts
+/**
+* Parse preserve words and phrases from the options
+* - Single words are added to preserveWords
+* - Multi-word phrases are added to preservePhrases and added to preserveWords with no spaces
+*/
+function parsePreserveWords(preserveWordsOption) {
+	const preserveWords = /* @__PURE__ */ new Map();
+	/**
+	* Add a single word to the preserveWords map
+	*/
+	function addPreserveWord(word) {
+		const lowerWord = word.toLowerCase();
+		let list = preserveWords.get(lowerWord);
+		if (!list) {
+			list = [];
+			preserveWords.set(lowerWord, list);
+		}
+		list.push(word);
+	}
+	const preservePhrases = /* @__PURE__ */ new Map();
+	for (const word of preserveWordsOption) {
+		const splitted = word.split(/\s+/);
+		if (splitted.length <= 1) addPreserveWord(word);
+		else {
+			preservePhrases.set(word, splitted);
+			addPreserveWord(splitted.join(""));
+		}
+	}
+	return {
+		preserveWords,
+		preservePhrases: [...preservePhrases.values()].sort((a, b) => b.length - a.length)
+	};
+}
+/**
+* Parse text into words with offsets
+*/
+function parseText(text, firstNode, lastNode) {
+	const words = [];
+	const pattern = /(\w+(?:[^\s\w]\w+)*|:\w+:|[^\s\w]+|\s+)/gu;
+	let match;
+	while ((match = pattern.exec(text)) !== null) {
+		const token = match[1];
+		if (/^\s+$/.test(token)) continue;
+		const punctuation = /^(?::\w+:|[^\s\w]+)$/.test(token);
+		words.push({
+			word: token,
+			offset: match.index,
+			punctuation,
+			first: false,
+			last: false
+		});
+	}
+	if (firstNode) {
+		for (const w of words) if (!w.punctuation) {
+			w.first = true;
+			break;
+		}
+	}
+	if (lastNode) for (let i = words.length - 1; i >= 0; i--) {
+		const w = words[i];
+		if (!w.punctuation) {
+			w.last = true;
+			break;
+		}
+	}
+	return words;
+}
+/**
+* Convert a single word based on case style and context
+*/
+function convertWord({ word, first, last }, caseStyle, minorWords) {
+	if (caseStyle === "Title Case") {
+		if (first || last) return {
+			word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+			isMinorWord: false
+		};
+		if (minorWords.some((minorWord) => minorWord.toLowerCase() === word.toLowerCase())) return {
+			word: word.toLowerCase(),
+			isMinorWord: true
+		};
+		return {
+			word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+			isMinorWord: false
+		};
+	}
+	if (first) return {
+		word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+		isMinorWord: false
+	};
+	return {
+		word: word.toLowerCase(),
+		isMinorWord: false
+	};
+}
+var heading_casing_default = createRule("heading-casing", {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "enforce consistent casing in headings.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: ["Title Case", "Sentence case"] },
+				preserveWords: {
+					type: "array",
+					items: { type: "string" },
+					description: "Words that should be preserved as-is (case-insensitive matching)"
+				},
+				ignorePatterns: {
+					type: "array",
+					items: { type: "string" },
+					description: "Regular expression patterns for words to ignore during casing checks"
+				},
+				minorWords: {
+					type: "array",
+					items: { type: "string" },
+					description: "Words that should not be capitalized in Title Case (unless they're the first or last word)"
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedTitleCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case).",
+			expectedTitleCaseMinorWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case - minor word).",
+			expectedSentenceCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Sentence case).",
+			expectedPreserveWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (preserved word)."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const caseStyle = context.options[0]?.style || "Title Case";
+		const { preserveWords, preservePhrases } = parsePreserveWords(context.options[0]?.preserveWords || defaultPreserveWords);
+		const minorWords = context.options[0]?.minorWords || defaultMinorWords;
+		const ignorePatterns = (context.options[0]?.ignorePatterns || [
+			"/^v\\d+/u",
+			"/\\w+\\.[a-z\\d]+$/u",
+			"/\\w*(?:API|Api)$/u",
+			"/\\w*(?:SDK|Sdk)$/u",
+			"/\\w*(?:CLI|Cli)$/u"
+		]).map((pattern) => {
+			if (isRegExp(pattern)) return toRegExp(pattern);
+			try {
+				return new RegExp(pattern, "v");
+			} catch {}
+			try {
+				return new RegExp(pattern, "u");
+			} catch {}
+			return new RegExp(pattern);
+		});
+		/**
+		* Check text node and report word-level errors
+		*/
+		function checkTextNode(node, firstNode, lastNode) {
+			const text = sourceCode.getText(node);
+			const wordAndOffsets = parseText(text, firstNode, lastNode);
+			const processed = /* @__PURE__ */ new Set();
+			for (let index = 0; index < wordAndOffsets.length; index++) {
+				if (processed.has(index)) continue;
+				processed.add(index);
+				const wordAndOffset = wordAndOffsets[index];
+				if (wordAndOffset.punctuation) continue;
+				if (ignorePatterns.some((pattern) => pattern.test(wordAndOffset.word))) continue;
+				const preservePhrase = findPreservePhrase(wordAndOffsets, index);
+				if (preservePhrase) {
+					for (let wordIndex = 0; wordIndex < preservePhrase.length; wordIndex++) {
+						processed.add(index + wordIndex);
+						verifyWord(wordAndOffsets[index + wordIndex], preservePhrase[wordIndex], "preserved");
+					}
+					continue;
+				}
+				const preserveWordList = preserveWords.get(wordAndOffset.word.toLowerCase());
+				if (preserveWordList) {
+					if (!preserveWordList.some((w) => w === wordAndOffset.word)) verifyWord(wordAndOffset, preserveWordList[0], "preserved");
+					continue;
+				}
+				const expectedWordResult = convertWord(wordAndOffset, caseStyle, minorWords);
+				verifyWord(wordAndOffset, expectedWordResult.word, expectedWordResult.isMinorWord ? "minor" : "normal");
+			}
+			/**
+			* Verify a single word against the expected casing
+			*/
+			function verifyWord(wordAndOffset, expectedWord, wordType = "normal") {
+				const { word, offset } = wordAndOffset;
+				if (word === expectedWord) return;
+				const nodeLoc = sourceCode.getLoc(node);
+				const beforeLines = text.slice(0, offset).split(/\n/u);
+				const line = nodeLoc.start.line + beforeLines.length - 1;
+				const column = (beforeLines.length === 1 ? nodeLoc.start.column : 1) + (beforeLines.at(-1) || "").length;
+				const nodeRange = sourceCode.getRange(node);
+				const wordRange = [nodeRange[0] + offset, nodeRange[0] + offset + word.length];
+				context.report({
+					node,
+					messageId: wordType === "preserved" ? "expectedPreserveWord" : caseStyle === "Title Case" ? wordType === "minor" ? "expectedTitleCaseMinorWord" : "expectedTitleCase" : "expectedSentenceCase",
+					data: {
+						actual: word,
+						expected: expectedWord
+					},
+					loc: {
+						start: {
+							line,
+							column
+						},
+						end: {
+							line,
+							column: column + word.length
+						}
+					},
+					fix(fixer) {
+						return fixer.replaceTextRange(wordRange, expectedWord);
+					}
+				});
+			}
+		}
+		/**
+		* Find a preserve phrase starting from the given index
+		* Returns the longest matching phrase or null if no match is found
+		*/
+		function findPreservePhrase(wordAndOffsets, index) {
+			const firstWord = wordAndOffsets[index];
+			if (firstWord.punctuation) return null;
+			const firstLowerWord = firstWord.word.toLowerCase();
+			let returnCandidate = null;
+			let subWords = null;
+			for (const phrase of preservePhrases) {
+				if (returnCandidate && returnCandidate.preservePhrase.length !== phrase.length) break;
+				if (firstLowerWord !== phrase[0].toLowerCase()) continue;
+				if (!subWords || subWords.length !== phrase.length) subWords = wordAndOffsets.slice(index, index + phrase.length).map((wo) => wo.word);
+				if (subWords.length === phrase.length && subWords.every((word, i) => word.toLowerCase() === phrase[i].toLowerCase())) {
+					let matchCount = 0;
+					for (let i = 0; i < subWords.length; i++) {
+						const word = subWords[i];
+						if (word === phrase[i]) matchCount++;
+					}
+					if (!returnCandidate || matchCount > returnCandidate.matchCount) returnCandidate = {
+						preservePhrase: phrase,
+						matchCount
+					};
+				}
+			}
+			return returnCandidate?.preservePhrase ?? null;
+		}
+		return { heading(node) {
+			if (!node.children.length) return;
+			const children = node.children.filter((child) => child.type !== "text" || child.value.trim());
+			children.forEach((child, i) => {
+				if (child.type === "text") checkTextNode(child, i === 0, i === node.children.length - 1);
+			});
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/no-text-backslash-linebreak.ts
 var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebreak", {
@@ -749,31 +1616,6 @@ 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", {
@@ -1060,8 +1902,10 @@ function normalizedURL(url) {
 //#endregion
 //#region src/utils/rules.ts
 const rules$1 = [
+	canonical_code_block_language_default,
 	definitions_last_default,
 	hard_linebreak_style_default,
+	heading_casing_default,
 	no_text_backslash_linebreak_default,
 	no_trailing_spaces_default,
 	prefer_inline_code_words_default,
@@ -1102,7 +1946,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.8.0";
+const version = "0.9.0";
 
 //#endregion
 //#region src/index.ts
@@ -1111,11 +1955,16 @@ const rules = rules$1.reduce((obj, r) => {
 	obj[r.meta.docs.ruleName] = r;
 	return obj;
 }, {});
+const resources = {
+	defaultPreserveWords,
+	defaultMinorWords
+};
 var src_default = {
 	meta: meta_exports,
 	configs,
-	rules
+	rules,
+	resources
 };
 
 //#endregion
-export { configs, src_default as default, meta_exports as meta, rules };
+export { configs, src_default as default, meta_exports as meta, resources, rules };

package/package.json

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