eslint-plugin-markdown-preferences 0.26.0 → 0.27.0

package/README.md

@@ -58,17 +58,18 @@ Example **eslint.config.js**:
 import { defineConfig } from "eslint/config";
 // import markdown from "@eslint/markdown";
 import markdownPreferences from "eslint-plugin-markdown-preferences";
-export default [
+export default defineConfig([
   // add more generic rule sets here, such as:
   // markdown.configs.recommended,
   markdownPreferences.configs.recommended,
   {
+    files: ["**/*.md", "*.md"],
     rules: {
       // override/add rules settings here, such as:
       // 'markdown-preferences/prefer-linked-words': 'error'
     },
   },
-];
+]);
 ```
 
 This plugin provides configs:
@@ -78,6 +79,49 @@ This plugin provides configs:
 
 See [the rule list](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/) to get the `rules` that this plugin provides.
 
+##### Using Extended Syntax
+
+This plugin experimentally supports some extended Markdown syntax.\
+To use these extended syntaxes, set the `markdown-preferences/extended-syntax` language option.
+
+```js
+import { defineConfig } from "eslint/config";
+import markdownPreferences from "eslint-plugin-markdown-preferences";
+export default defineConfig([
+  {
+    extends: [markdownPreferences.configs.recommended],
+    language: "markdown-preferences/extended-syntax",
+  },
+]);
+```
+
+The following syntaxes are supported:
+
+- [Custom Containers](https://vitepress.dev/guide/markdown#custom-containers)\
+  Example:
+
+  ```md
+  ::: warning
+  This is a warning box.
+  :::
+  ```
+
+- [Mathematical Expressions](https://docs.github.com/get-started/writing-on-github/working-with-advanced-formatting/writing-mathematical-expressions)\
+  Example:
+
+  ```md
+  $$
+  E = mc^2
+  $$
+  ```
+
+- [VitePress-style Import Code Snippets](https://vitepress.dev/guide/markdown#import-code-snippets) syntax using triple left angle brackets\
+  Example:
+
+  ```md
+  <<< @/filepath
+  ```
+
 #### Legacy Config (`.eslintrc`)
 
 Is not supported.

package/lib/index.d.ts

@@ -1,7 +1,12 @@
 import markdown from "@eslint/markdown";
+import * as math from "mdast-util-math";
 import * as _eslint_core0 from "@eslint/core";
-import { RuleDefinition } from "@eslint/core";
+import { File, Language, OkParseResult, ParseResult, RuleDefinition, SourceLocation } from "@eslint/core";
 import { ESLint, Linter } from "eslint";
+import * as eslint from "@eslint/markdown/types";
+import { MarkdownLanguageContext, MarkdownLanguageOptions } from "@eslint/markdown/types";
+import * as mdast from "mdast";
+import { TextSourceCodeBase } from "@eslint/plugin-kit";
 
 //#region src/rule-types.d.ts
 declare module 'eslint' {
@@ -380,12 +385,12 @@ type MarkdownPreferencesOrderedListMarkerStyle = [] | [{
   }[];
 }];
 type MarkdownPreferencesPaddingLineBetweenBlocks = {
-  prev: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]] | {
-    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]]);
+  prev: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"))[]] | {
+    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"))[]]);
     in?: ("list" | "blockquote" | "footnote-definition");
   });
-  next: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]] | {
-    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]]);
+  next: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"))[]] | {
+    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "custom-container" | "math" | "import-code-snippet" | "*"))[]]);
     in?: ("list" | "blockquote" | "footnote-definition");
   });
   blankLine: ("any" | "never" | "always");
@@ -498,7 +503,161 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.26.0";
+declare const version: "0.27.0";
+//#endregion
+//#region src/language/ast-types.d.ts
+type Node = mdast.Node;
+type Root = ExtendChildren<mdast.Root, RootContent>;
+type Blockquote = ExtendChildren<mdast.Blockquote, CustomContainer>;
+type Break = mdast.Break;
+type Code = mdast.Code;
+type Definition = mdast.Definition;
+type Delete = mdast.Delete;
+type Emphasis = mdast.Emphasis;
+type FootnoteDefinition = ExtendChildren<mdast.FootnoteDefinition, CustomContainer>;
+type FootnoteReference = mdast.FootnoteReference;
+type Heading = mdast.Heading;
+type Html = mdast.Html;
+type Image = mdast.Image;
+type ImageReference = mdast.ImageReference;
+type InlineCode = mdast.InlineCode;
+type Link = mdast.Link;
+type LinkReference = mdast.LinkReference;
+type List = mdast.List;
+type ListItem = ExtendChildren<mdast.ListItem, CustomContainer>;
+type Paragraph = mdast.Paragraph;
+type Strong = mdast.Strong;
+type Table = mdast.Table;
+type TableCell = mdast.TableCell;
+type TableRow = mdast.TableRow;
+type Text = mdast.Text;
+type ThematicBreak = mdast.ThematicBreak;
+type Yaml = mdast.Yaml;
+type Math = math.Math;
+type InlineMath = math.InlineMath;
+type Toml = eslint.Toml;
+type Json = eslint.Json;
+interface CustomContainer extends ExtendChildren<mdast.Parent, CustomContainer | ImportCodeSnippet> {
+  /**
+   * Node type of mdast custom container.
+   */
+  type: "customContainer";
+  /**
+   * Info string (e.g., "warning" in ::: warning ... :::).
+   */
+  info: string | null;
+  /**
+   * Children of custom container.
+   */
+  children: (CustomContainer | BlockContent | DefinitionContent)[];
+}
+interface ImportCodeSnippet extends mdast.Literal {
+  /**
+   * Node type of mdast import code snippet.
+   */
+  type: "importCodeSnippet";
+}
+type RootContent = RootContentMap[keyof RootContentMap];
+type BlockContent = RootContentMap[keyof mdast.BlockContentMap] | ImportCodeSnippet;
+type DefinitionContent = RootContentMap[keyof mdast.DefinitionContentMap];
+type ExtendChildren<N extends mdast.Node & {
+  children: mdast.Node[];
+}, C extends mdast.Node> = Omit<N, "children"> & {
+  children: (MapChild<N["children"][number]> | C)[];
+};
+type MapChild<N extends mdast.Node> = N["type"] extends RootContent["type"] ? RootContentMap[N["type"]] : N;
+interface RootContentMap {
+  blockquote: Blockquote;
+  break: Break;
+  code: Code;
+  definition: Definition;
+  delete: Delete;
+  emphasis: Emphasis;
+  footnoteDefinition: FootnoteDefinition;
+  footnoteReference: FootnoteReference;
+  heading: Heading;
+  html: Html;
+  image: Image;
+  imageReference: ImageReference;
+  inlineCode: InlineCode;
+  link: Link;
+  linkReference: LinkReference;
+  list: List;
+  listItem: ListItem;
+  paragraph: Paragraph;
+  strong: Strong;
+  table: Table;
+  tableCell: TableCell;
+  tableRow: TableRow;
+  text: Text;
+  thematicBreak: ThematicBreak;
+  yaml: Yaml;
+  toml: Toml;
+  json: Json;
+  customContainer: CustomContainer;
+  inlineMath: InlineMath;
+  math: Math;
+  importCodeSnippet: ImportCodeSnippet;
+}
+//#endregion
+//#region src/language/extended-markdown-ianguage.d.ts
+type ExtendedMarkdownSourceCode = TextSourceCodeBase<{
+  LangOptions: MarkdownLanguageOptions;
+  RootNode: Root;
+  SyntaxElementWithLoc: Node;
+  ConfigNode: {
+    value: string;
+    position: SourceLocation;
+  };
+}>;
+declare class ExtendedMarkdownLanguage implements Language {
+  /**
+   * The type of file to read.
+   * @type {"text"}
+   */
+  readonly fileType: "text";
+  /**
+   * The line number at which the parser starts counting.
+   * @type {0|1}
+   */
+  readonly lineStart: 0 | 1;
+  /**
+   * The column number at which the parser starts counting.
+   * @type {0|1}
+   */
+  readonly columnStart: 0 | 1;
+  /**
+   * The name of the key that holds the type of the node.
+   * @type {string}
+   */
+  readonly nodeTypeKey: string;
+  /**
+   * Default language options. User-defined options are merged with this object.
+   * @type {MarkdownLanguageOptions}
+   */
+  readonly defaultLanguageOptions: MarkdownLanguageOptions;
+  /**
+   * Validates the language options.
+   * @param {MarkdownLanguageOptions} languageOptions The language options to validate.
+   * @returns {void}
+   * @throws {Error} When the language options are invalid.
+   */
+  validateLanguageOptions(languageOptions: MarkdownLanguageOptions): void;
+  /**
+   * Parses the given file into an AST.
+   * @param {File} file The virtual file to parse.
+   * @param {MarkdownLanguageContext} _context The options to use for parsing.
+   * @returns {ParseResult<Root>} The result of parsing.
+   */
+  parse(file: File, _context: MarkdownLanguageContext): ParseResult<Root>;
+  /**
+   * Creates a new `MarkdownSourceCode` object from the given information.
+   * @param {File} file The virtual file to create a `MarkdownSourceCode` object from.
+   * @param {OkParseResult<Root>} parseResult The result returned from `parse()`.
+   * @returns {MarkdownSourceCode} The new `MarkdownSourceCode` object.
+   */
+  createSourceCode(file: File, parseResult: OkParseResult<Root>): ExtendedMarkdownSourceCode;
+}
 //#endregion
 //#region src/index.d.ts
 declare const configs: {
@@ -510,8 +669,14 @@ declare const resources: {
   defaultPreserveWords: string[];
   defaultMinorWords: string[];
 };
+declare const languages: {
+  "extended-syntax": ExtendedMarkdownLanguage;
+};
 declare const _default: {
   meta: typeof meta_d_exports;
+  languages: {
+    "extended-syntax": ExtendedMarkdownLanguage;
+  };
   configs: {
     recommended: typeof recommended_d_exports;
     standard: typeof standard_d_exports;
@@ -523,4 +688,4 @@ declare const _default: {
   };
 };
 //#endregion
-export { RuleOptions, configs, _default as default, meta_d_exports as meta, resources, rules };
+export { RuleOptions, configs, _default as default, languages, meta_d_exports as meta, resources, rules };

package/lib/index.js

@@ -3,6 +3,16 @@ import stringWidth from "string-width";
 import emojiRegex from "emoji-regex-xs";
 import path from "node:path";
 import markdown from "@eslint/markdown";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { frontmatter } from "micromark-extension-frontmatter";
+import { gfm } from "micromark-extension-gfm";
+import { math } from "micromark-extension-math";
+import { mathFromMarkdown } from "mdast-util-math";
+import { markdownLineEnding, markdownSpace } from "micromark-util-character";
+import { codes, constants, types } from "micromark-util-symbol";
+import { factorySpace } from "micromark-factory-space";
 
 //#region src/utils/index.ts
 /**
@@ -957,14 +967,14 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 				if (node.ordered) return;
 				checkBulletList(node);
 			},
-			"root, blockquote, listItem, footnoteDefinition"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				containerStack = {
 					node,
 					level: node.type === "listItem" ? containerStack.level + 1 : 1,
 					upper: containerStack
 				};
 			},
-			"root, blockquote, listItem, footnoteDefinition:exit"() {
+			"root, blockquote, listItem, footnoteDefinition, customContainer:exit"() {
 				containerStack = containerStack.upper;
 			}
 		};
@@ -1117,10 +1127,10 @@ var canonical_code_block_language_default = createRule("canonical-code-block-lan
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const languages = context.options[0]?.languages || DEFAULT_LANGUAGES;
+		const languages$1 = context.options[0]?.languages || DEFAULT_LANGUAGES;
 		return { code(node) {
-			if (!node.lang || !languages[node.lang]) return;
-			const canonical = languages[node.lang];
+			if (!node.lang || !languages$1[node.lang]) return;
+			const canonical = languages$1[node.lang];
 			const current = node.lang;
 			if (current === canonical) return;
 			const parsed = parseFencedCodeBlock(sourceCode, node);
@@ -1542,7 +1552,12 @@ var definitions_last_default = createRule("definitions-last", {
 				if (c === "\n") lineFeeds++;
 			}
 			yield fixer.removeRange([rangeStart, range[1]]);
-			let insertText = sourceCode.text.slice(rangeStart, lineStart) + sourceCode.text.slice(...range);
+			const startColumnOffset = loc.start.column - 1;
+			const insertLines = sourceCode.lines.slice(loc.start.line - 1, loc.end.line).map((lineText, i, arr) => {
+				if (i === arr.length - 1) return lineText.slice(startColumnOffset, loc.end.column - 1);
+				return lineText.slice(startColumnOffset);
+			});
+			let insertText = sourceCode.text.slice(rangeStart, lineStart) + insertLines.join(/\r?\n/u.exec(sourceCode.text)?.[0] ?? "\n");
 			if (prev.type === "footnoteDefinition" && node.type !== "footnoteDefinition" && lineFeeds <= 1) insertText = `\n${insertText}`;
 			if (next && node.type === "footnoteDefinition" && next.type !== "footnoteDefinition") {
 				const prevLoc = sourceCode.getLoc(prev);
@@ -5291,6 +5306,108 @@ function parseListItem(sourceCode, node) {
 	};
 }
 
+//#endregion
+//#region src/utils/math-block.ts
+/**
+* Parse the math block.
+*/
+function parseMathBlock(sourceCode, node) {
+	const range = sourceCode.getRange(node);
+	const text = sourceCode.text.slice(...range);
+	const parsedOpening = parseMathOpeningSequenceFromText(text);
+	if (parsedOpening === null) return null;
+	const openingSequenceRange = [range[0], range[0] + parsedOpening.openingSequence.length];
+	const openingSequence = {
+		text: parsedOpening.openingSequence,
+		range: openingSequenceRange,
+		loc: getSourceLocationFromRange(sourceCode, node, openingSequenceRange)
+	};
+	const parsedClosing = parseMathClosingSequenceFromText(text);
+	if (parsedClosing == null) return null;
+	const spaceAfterClosingRange = [range[1] - parsedClosing.after.length, range[1]];
+	const spaceAfterClosing = {
+		text: parsedClosing.after,
+		range: spaceAfterClosingRange,
+		loc: getSourceLocationFromRange(sourceCode, node, spaceAfterClosingRange)
+	};
+	const closingSequenceRange = [spaceAfterClosing.range[0] - parsedClosing.closingSequence.length, spaceAfterClosing.range[0]];
+	const closingSequence = {
+		text: parsedClosing.closingSequence,
+		range: closingSequenceRange,
+		loc: getSourceLocationFromRange(sourceCode, node, closingSequenceRange)
+	};
+	const contentRange = [openingSequence.range[1] + parsedOpening.after.length, closingSequence.range[0] - parsedClosing.before.length];
+	const contentText = sourceCode.text.slice(...contentRange);
+	return {
+		openingSequence,
+		content: {
+			text: contentText,
+			range: contentRange,
+			loc: getSourceLocationFromRange(sourceCode, node, contentRange)
+		},
+		closingSequence,
+		after: spaceAfterClosing.range[0] < spaceAfterClosing.range[1] ? spaceAfterClosing : null
+	};
+}
+/**
+* Parse the opening sequence from a text string.
+*/
+function parseMathOpeningSequenceFromText(text) {
+	if (!text.startsWith("$")) return null;
+	let openingSequenceAfterOffset = 1;
+	while (openingSequenceAfterOffset < text.length && text[openingSequenceAfterOffset] === "$") openingSequenceAfterOffset++;
+	const afterOffset = skipWhitespace(openingSequenceAfterOffset);
+	if (afterOffset === openingSequenceAfterOffset || afterOffset >= text.length) return null;
+	return {
+		openingSequence: text.slice(0, openingSequenceAfterOffset),
+		after: text.slice(openingSequenceAfterOffset, afterOffset)
+	};
+	/**
+	* Skip whitespace characters at the start of the text.
+	*/
+	function skipWhitespace(index) {
+		let inIndent = false;
+		let result = index;
+		let c;
+		while (result < text.length && (c = text[result]) && (isWhitespace(c) || inIndent && c === ">")) {
+			result++;
+			if (c === "\n") inIndent = true;
+			else if (inIndent) inIndent = isWhitespace(c) || c === ">";
+		}
+		return result;
+	}
+}
+/**
+* Parse the closing sequence from a text string.
+*/
+function parseMathClosingSequenceFromText(text) {
+	const trimmedEndOffset = skipEndWhitespace(text.length - 1) + 1;
+	if (trimmedEndOffset <= 0 || text[trimmedEndOffset - 1] !== "$") return null;
+	let closingSequenceBeforeOffset = trimmedEndOffset - 2;
+	while (closingSequenceBeforeOffset >= 0 && text[closingSequenceBeforeOffset] === "$") closingSequenceBeforeOffset--;
+	const beforeOffset = skipEndWhitespace(closingSequenceBeforeOffset);
+	if (beforeOffset === closingSequenceBeforeOffset || beforeOffset < 0) return null;
+	return {
+		before: text.slice(beforeOffset + 1, closingSequenceBeforeOffset + 1),
+		closingSequence: text.slice(closingSequenceBeforeOffset + 1, trimmedEndOffset),
+		after: text.slice(trimmedEndOffset)
+	};
+	/**
+	* Skip whitespace characters at the end of the text.
+	*/
+	function skipEndWhitespace(index) {
+		let result = index;
+		let c;
+		while (result >= 0 && (c = text[result]) && isWhitespace(c)) result--;
+		if (c === ">") {
+			let index2 = result - 1;
+			while (index2 >= 0 && (c = text[index2]) && (isSpaceOrTab(c) || c === ">")) index2--;
+			if (c === "\n") return skipEndWhitespace(index2);
+		}
+		return result;
+	}
+}
+
 //#endregion
 //#region src/rules/indent.ts
 /**
@@ -5570,7 +5687,10 @@ var indent_default = createRule("indent", {
 			definition: verifyLinkDefinition,
 			table: verifyTable,
 			list: verifyList,
-			inlineCode: verifyInlineCode,
+			customContainer: verifyCustomContainer,
+			math: verifyMathBlock,
+			importCodeSnippet: verifyImportCodeSnippet,
+			inlineCode: verifyInlineCodeOrInlineMath,
 			emphasis: verifyEmphasisOrStrongOrDelete,
 			strong: verifyEmphasisOrStrongOrDelete,
 			delete: verifyEmphasisOrStrongOrDelete,
@@ -5579,6 +5699,7 @@ var indent_default = createRule("indent", {
 			footnoteReference: verifyInline,
 			break: verifyInline,
 			text: verifyText,
+			inlineMath: verifyInlineCodeOrInlineMath,
 			blockquote(node) {
 				verifyBlockquote(node);
 				blockStack = new BlockquoteStack(node);
@@ -5635,32 +5756,9 @@ var indent_default = createRule("indent", {
 			verifyLinesIndent([loc.start.line, loc.end.line], (lineNumber) => blockStack.getExpectedIndent({
 				lineNumber,
 				block: true
-			}), additionalFixes);
-			/**
-			* Additional fixes for code block content lines.
-			*/
-			function* additionalFixes(fixer, info) {
-				if (info.loc.start.line !== loc.start.line) return;
-				for (let lineNumber = loc.start.line + 1; lineNumber < loc.end.line; lineNumber++) {
-					const line = getParsedLines(sourceCode).get(lineNumber);
-					if (!line) continue;
-					if (info.expectedIndentWidth > info.actualIndentWidth) {
-						const before = sliceWidth(line.text, 0, info.actualIndentWidth);
-						const after = sliceWidth(line.text, info.actualIndentWidth);
-						const diffWidth = info.expectedIndentWidth - info.actualIndentWidth;
-						yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + " ".repeat(diffWidth) + after);
-					} else {
-						let before = sliceWidth(line.text, 0, info.expectedIndentWidth);
-						let between = sliceWidth(line.text, info.expectedIndentWidth, info.actualIndentWidth);
-						const after = sliceWidth(line.text, info.actualIndentWidth);
-						while (between && !isSpaceOrTab(between)) {
-							before += between[0];
-							between = between.slice(1);
-						}
-						yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + after);
-					}
-				}
-			}
+			}), (fixer, info) => {
+				return additionalFixesForCodeBlock(node, fixer, info, loc.start.line + 1, loc.end.line - 1);
+			});
 		}
 		/**
 		* Verify an HTML node.
@@ -5777,6 +5875,41 @@ var indent_default = createRule("indent", {
 			}
 		}
 		/**
+		* Verify a custom container node.
+		*/
+		function verifyCustomContainer(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent([loc.start.line, loc.end.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify a math node.
+		*/
+		function verifyMathBlock(node) {
+			const parsed = parseMathBlock(sourceCode, node);
+			if (!parsed) return;
+			const loc = sourceCode.getLoc(node);
+			const endLineToBeChecked = inlineToBeChecked(parsed.closingSequence.loc.start);
+			verifyLinesIndent(endLineToBeChecked ? [loc.start.line, loc.end.line] : [loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}), (fixer, info) => {
+				return additionalFixesForCodeBlock(node, fixer, info, loc.start.line + 1, endLineToBeChecked ? loc.end.line - 1 : loc.end.line);
+			});
+		}
+		/**
+		* Verify an import code snippet node.
+		*/
+		function verifyImportCodeSnippet(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
 		* Verify a footnote definition node.
 		*/
 		function verifyFootnoteDefinition(node) {
@@ -5787,9 +5920,9 @@ var indent_default = createRule("indent", {
 			}));
 		}
 		/**
-		* Verify an inline code node.
+		* Verify an inline code/math node.
 		*/
-		function verifyInlineCode(node) {
+		function verifyInlineCodeOrInlineMath(node) {
 			const loc = sourceCode.getLoc(node);
 			if (!inlineToBeChecked(loc.start)) return;
 			verifyLinesIndent([loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
@@ -6171,6 +6304,32 @@ var indent_default = createRule("indent", {
 				actualIndentWidth
 			};
 		}
+		/**
+		* Additional fixes for code/math block content lines.
+		*/
+		function* additionalFixesForCodeBlock(node, fixer, info, fixStartLine, fixEndLine) {
+			const loc = sourceCode.getLoc(node);
+			if (info.loc.start.line !== loc.start.line) return;
+			for (let lineNumber = fixStartLine; lineNumber <= fixEndLine; lineNumber++) {
+				const line = getParsedLines(sourceCode).get(lineNumber);
+				if (!line) continue;
+				if (info.expectedIndentWidth > info.actualIndentWidth) {
+					const before = sliceWidth(line.text, 0, info.actualIndentWidth);
+					const after = sliceWidth(line.text, info.actualIndentWidth);
+					const diffWidth = info.expectedIndentWidth - info.actualIndentWidth;
+					yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + " ".repeat(diffWidth) + after);
+				} else {
+					let before = sliceWidth(line.text, 0, info.expectedIndentWidth);
+					let between = sliceWidth(line.text, info.expectedIndentWidth, info.actualIndentWidth);
+					const after = sliceWidth(line.text, info.actualIndentWidth);
+					while (between && !isSpaceOrTab(between)) {
+						before += between[0];
+						between = between.slice(1);
+					}
+					yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + after);
+				}
+			}
+		}
 	}
 });
 
@@ -8307,14 +8466,14 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 			}
 		}
 		return {
-			"blockquote, listItem, footnoteDefinition"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				scope = {
 					node,
 					upper: scope,
 					last: null
 				};
 			},
-			"blockquote, listItem, footnoteDefinition:exit"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer:exit"(node) {
 				if (scope.node === node) scope = scope.upper;
 			},
 			heading() {
@@ -8396,14 +8555,14 @@ var ordered_list_marker_start_default = createRule("ordered-list-marker-start",
 			});
 		}
 		return {
-			"blockquote, listItem, footnoteDefinition"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				scope = {
 					node,
 					upper: scope,
 					last: null
 				};
 			},
-			"blockquote, listItem, footnoteDefinition:exit"(node) {
+			"blockquote, listItem, footnoteDefinition, customContainer:exit"(node) {
 				if (scope.node === node) scope = scope.upper;
 			},
 			heading() {
@@ -8576,14 +8735,14 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 				if (!node.ordered) return;
 				checkOrderedList(node);
 			},
-			"root, blockquote, listItem, footnoteDefinition"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				containerStack = {
 					node,
 					level: node.type === "listItem" ? containerStack.level + 1 : 1,
 					upper: containerStack
 				};
 			},
-			"root, blockquote, listItem, footnoteDefinition:exit"() {
+			"root, blockquote, listItem, footnoteDefinition, customContainer:exit"() {
 				containerStack = containerStack.upper;
 			}
 		};
@@ -8631,6 +8790,9 @@ const BLOCK_TYPES = [
 	"link-definition",
 	"footnote-definition",
 	"frontmatter",
+	"custom-container",
+	"math",
+	"import-code-snippet",
 	"*"
 ];
 const BLOCK_TYPE_SCHEMAS = [{
@@ -8670,7 +8832,10 @@ const BLOCK_TYPE_MAP = {
 	footnoteDefinition: "footnote-definition",
 	json: "frontmatter",
 	toml: "frontmatter",
-	yaml: "frontmatter"
+	yaml: "frontmatter",
+	customContainer: "custom-container",
+	math: "math",
+	importCodeSnippet: "import-code-snippet"
 };
 /**
 * Get the block type of a node
@@ -8866,10 +9031,10 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 			}
 		}
 		return {
-			"root, blockquote, listItem, footnoteDefinition"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer"(node) {
 				containerStack.unshift(node);
 			},
-			"root, blockquote, listItem, footnoteDefinition:exit"(node) {
+			"root, blockquote, listItem, footnoteDefinition, customContainer:exit"(node) {
 				checkBlockPadding(node);
 				containerStack.shift();
 			}
@@ -11219,7 +11384,440 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.26.0";
+const version = "0.27.0";
+
+//#endregion
+//#region src/language/extensions/micromark-custom-container.ts
+/**
+* Micromark extension to support custom containers (e.g., ::: warning ... :::).
+*/
+function customContainer() {
+	const customContainerOpenConstruct = {
+		name: "customContainer",
+		continuation: {
+			name: "customContainerContinuation",
+			tokenize(effects, ok, nok) {
+				return tokenizeCustomContainerContinuation(this, effects, ok, nok);
+			}
+		},
+		exit(effects) {
+			effects.exit("customContainer");
+		},
+		tokenize(effects, ok, nok) {
+			return tokenizeCustomContainerOpen(this, effects, ok, nok);
+		}
+	};
+	const customContainerCloseConstruct = {
+		name: "customContainerCloseConstruct",
+		tokenize(effects, ok, nok) {
+			return tokenizeCustomContainerClose(this, effects, ok, nok);
+		}
+	};
+	return { document: { [codes.colon]: customContainerOpenConstruct } };
+	/**
+	* Continuation tokenizer for the opening marker of the custom container.
+	*/
+	function tokenizeCustomContainerOpen(self, effects, ok, nok) {
+		let size = 0;
+		let openToken;
+		const infoCodes = [];
+		return start;
+		/**
+		* Process start for the opening marker of the custom container.
+		*/
+		function start(code) {
+			if (code !== codes.colon) return nok(code);
+			size = 0;
+			openToken = effects.enter("customContainer", { _container: true });
+			effects.enter("customContainerFence");
+			effects.enter("customContainerFenceSequence");
+			return sequence;
+		}
+		/**
+		* Process sequence for the opening marker of the custom container.
+		*
+		* ```markdown
+		* > | ::: info
+		*     ^
+		* ```
+		*/
+		function sequence(code) {
+			if (code === codes.colon) {
+				size++;
+				effects.consume(code);
+				return sequence;
+			}
+			if (size < 3) return nok(code);
+			effects.exit("customContainerFenceSequence");
+			return markdownSpace(code) ? factorySpace(effects, infoBefore, types.whitespace)(code) : infoBefore(code);
+		}
+		/**
+		* Process before info for the opening marker of the custom container.
+		*
+		* ```markdown
+		* > | ::: info
+		*        ^
+		* ```
+		*/
+		function infoBefore(code) {
+			if (code === codes.eof || markdownLineEnding(code)) return nok(code);
+			openToken._customContainer = { size };
+			self.containerState._customContainer = { open: openToken };
+			effects.enter("customContainerFenceInfo");
+			effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+			infoCodes.length = 0;
+			return info(code);
+		}
+		/**
+		* Process info for the opening marker of the custom container.
+		*
+		* ```markdown
+		* > | ::: info
+		*         ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function info(code) {
+			if (code === codes.eof || markdownLineEnding(code)) {
+				effects.exit(types.chunkString);
+				effects.exit("customContainerFenceInfo");
+				effects.exit("customContainerFence");
+				openToken._customContainer.info = String.fromCharCode(...infoCodes);
+				return ok(code);
+			}
+			infoCodes.push(code);
+			effects.consume(code);
+			return info;
+		}
+	}
+	/**
+	* Continuation tokenizer for the closing marker of the custom container.
+	*/
+	function tokenizeCustomContainerClose(self, effects, ok, nok) {
+		let size = 0;
+		return start;
+		/**
+		* Process start for the closing marker of the custom container.
+		*/
+		function start(code) {
+			if (code !== codes.colon) return nok(code);
+			size = 0;
+			effects.enter("customContainerFence");
+			effects.enter("customContainerFenceSequence");
+			return sequence;
+		}
+		/**
+		* Process sequence for the closing marker of the custom container.
+		*
+		* ```markdown
+		* > | :::
+		* ```
+		*/
+		function sequence(code) {
+			if (code === codes.colon) {
+				size++;
+				effects.consume(code);
+				return sequence;
+			}
+			if (size < 3) return nok(code);
+			effects.exit("customContainerFenceSequence");
+			return markdownSpace(code) ? factorySpace(effects, after, types.whitespace)(code) : after(code);
+		}
+		/**
+		* Process after for the closing marker of the custom container.
+		*
+		* ```markdown
+		* > | :::
+		*        ^
+		* ```
+		*/
+		function after(code) {
+			if (code === codes.eof || markdownLineEnding(code)) {
+				if (!self.containerState) throw new Error("containerState is undefined");
+				const openToken = self.containerState._customContainer?.open;
+				if (openToken?._customContainer?.size === size) {
+					openToken._customContainer.closed = true;
+					self.containerState._closeFlow = true;
+					effects.exit("customContainerFence");
+					return ok(code);
+				}
+			}
+			return nok(code);
+		}
+	}
+	/**
+	* Continuation tokenizer for the custom container.
+	*/
+	function tokenizeCustomContainerContinuation(self, effects, ok, nok) {
+		if (self.containerState?._customContainer?.open?._customContainer?.closed) {
+			self.containerState._closeFlow = true;
+			return nok;
+		}
+		return start;
+		/**
+		* Process start for the custom container.
+		*/
+		function start(code) {
+			if (code !== codes.colon) return ok(code);
+			return effects.attempt(customContainerCloseConstruct, () => {
+				self.containerState._closeFlow = true;
+				return ok;
+			}, ok);
+		}
+	}
+}
+
+//#endregion
+//#region src/language/extensions/mdast-custom-container.ts
+/**
+* Mdast extension to support custom containers (e.g., ::: warning ... :::).
+*/
+function customContainerFromMarkdown() {
+	return {
+		enter: {
+			customContainer(token) {
+				this.enter({
+					type: "customContainer",
+					children: [],
+					info: null
+				}, token);
+			},
+			customContainerFenceInfo() {
+				this.buffer();
+			}
+		},
+		exit: {
+			customContainer(token) {
+				this.exit(token);
+			},
+			customContainerFenceInfo() {
+				const data = this.resume();
+				const node = this.stack[this.stack.length - 1];
+				node.info = data;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/language/extensions/micromark-import-code-snippet.ts
+/**
+* Micromark extension to support [VitePress-style Import Code Snippets](https://vitepress.dev/guide/markdown#import-code-snippets) syntax using triple left angle brackets.
+*/
+function importCodeSnippet() {
+	const importCodeSnippetConstruct = {
+		name: "importCodeSnippet",
+		tokenize(effects, ok, nok) {
+			return tokenizeImportCodeSnippet(this, effects, ok, nok);
+		}
+	};
+	return { flow: { [codes.lessThan]: importCodeSnippetConstruct } };
+	/**
+	* Tokenizer for the import code snippet.
+	*/
+	function tokenizeImportCodeSnippet(_self, effects, ok, nok) {
+		let size = 0;
+		return start;
+		/**
+		* Process start for the opening marker of the import code snippet.
+		*/
+		function start(code) {
+			if (code !== codes.lessThan) return nok(code);
+			size = 0;
+			effects.enter("importCodeSnippet");
+			effects.enter("importCodeSnippetMarkerSequence");
+			return sequence(code);
+		}
+		/**
+		* Process the sequence of opening markers for the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*     ^^^
+		* ```
+		*/
+		function sequence(code) {
+			if (code === codes.lessThan) {
+				size++;
+				effects.consume(code);
+				return sequence;
+			}
+			if (size < 3) return nok(code);
+			effects.exit("importCodeSnippetMarkerSequence");
+			return markdownSpace(code) ? factorySpace(effects, afterMarker, types.whitespace)(code) : afterMarker(code);
+		}
+		/**
+		* Process after the opening marker of the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*         ^
+		* ```
+		*/
+		function afterMarker(code) {
+			if (code === codes.eof || markdownLineEnding(code)) return nok(code);
+			effects.enter("importCodeSnippetPath");
+			effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+			return importPath(code);
+		}
+		/**
+		* Process the path of the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*         ^^^^^^^^^^^^^^^^^
+		* ```
+		*/
+		function importPath(code) {
+			if (code === codes.eof || markdownLineEnding(code) || markdownSpace(code)) {
+				effects.exit(types.chunkString);
+				effects.exit("importCodeSnippetPath");
+				effects.exit("importCodeSnippet");
+				return afterPath(code);
+			}
+			effects.consume(code);
+			return importPath;
+		}
+		/**
+		* Process after the path of the import code snippet.
+		*
+		* ```markdown
+		* > | <<< ./path/to/code.ts
+		*                          ^
+		* ```
+		*/
+		function afterPath(code) {
+			if (code === codes.eof || markdownLineEnding(code)) return ok(code);
+			if (markdownSpace(code)) return factorySpace(effects, afterPath, types.whitespace)(code);
+			return nok(code);
+		}
+	}
+}
+
+//#endregion
+//#region src/language/extensions/mdast-import-code-snippet.ts
+/**
+* Mdast extension to support [VitePress-style Import Code Snippets](https://vitepress.dev/guide/markdown#import-code-snippets) syntax using triple left angle brackets.
+*/
+function importCodeSnippetFromMarkdown() {
+	return {
+		enter: {
+			importCodeSnippet(token) {
+				this.enter({
+					type: "importCodeSnippet",
+					value: ""
+				}, token);
+			},
+			importCodeSnippetPath() {
+				this.buffer();
+			}
+		},
+		exit: {
+			importCodeSnippet(token) {
+				this.exit(token);
+			},
+			importCodeSnippetPath() {
+				const data = this.resume();
+				const node = this.stack[this.stack.length - 1];
+				node.value = data;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/language/parser.ts
+/**
+* Parse Extended Markdown to MDAST.
+*/
+function parseExtendedMarkdown(code) {
+	const options = {
+		extensions: [
+			gfm(),
+			frontmatter(["yaml", "toml"]),
+			math(),
+			customContainer(),
+			importCodeSnippet()
+		],
+		mdastExtensions: [
+			gfmFromMarkdown(),
+			frontmatterFromMarkdown(["yaml", "toml"]),
+			mathFromMarkdown(),
+			customContainerFromMarkdown(),
+			importCodeSnippetFromMarkdown()
+		]
+	};
+	return fromMarkdown(code, options);
+}
+
+//#endregion
+//#region src/language/extended-markdown-ianguage.ts
+var ExtendedMarkdownLanguage = class {
+	/**
+	* The type of file to read.
+	* @type {"text"}
+	*/
+	fileType = markdown.languages.gfm.fileType;
+	/**
+	* The line number at which the parser starts counting.
+	* @type {0|1}
+	*/
+	lineStart = markdown.languages.gfm.lineStart;
+	/**
+	* The column number at which the parser starts counting.
+	* @type {0|1}
+	*/
+	columnStart = markdown.languages.gfm.columnStart;
+	/**
+	* The name of the key that holds the type of the node.
+	* @type {string}
+	*/
+	nodeTypeKey = markdown.languages.gfm.nodeTypeKey;
+	/**
+	* Default language options. User-defined options are merged with this object.
+	* @type {MarkdownLanguageOptions}
+	*/
+	defaultLanguageOptions = markdown.languages.gfm.defaultLanguageOptions;
+	/**
+	* Validates the language options.
+	* @param {MarkdownLanguageOptions} languageOptions The language options to validate.
+	* @returns {void}
+	* @throws {Error} When the language options are invalid.
+	*/
+	validateLanguageOptions(languageOptions$2) {
+		return markdown.languages.gfm.validateLanguageOptions(languageOptions$2);
+	}
+	/**
+	* Parses the given file into an AST.
+	* @param {File} file The virtual file to parse.
+	* @param {MarkdownLanguageContext} _context The options to use for parsing.
+	* @returns {ParseResult<Root>} The result of parsing.
+	*/
+	parse(file, _context) {
+		const text = file.body;
+		try {
+			return {
+				ok: true,
+				ast: parseExtendedMarkdown(text)
+			};
+		} catch (ex) {
+			return {
+				ok: false,
+				errors: [ex]
+			};
+		}
+	}
+	/**
+	* Creates a new `MarkdownSourceCode` object from the given information.
+	* @param {File} file The virtual file to create a `MarkdownSourceCode` object from.
+	* @param {OkParseResult<Root>} parseResult The result returned from `parse()`.
+	* @returns {MarkdownSourceCode} The new `MarkdownSourceCode` object.
+	*/
+	createSourceCode(file, parseResult) {
+		return markdown.languages.gfm.createSourceCode(file, parseResult);
+	}
+};
 
 //#endregion
 //#region src/index.ts
@@ -11235,12 +11833,14 @@ const resources = {
 	defaultPreserveWords,
 	defaultMinorWords
 };
+const languages = { "extended-syntax": new ExtendedMarkdownLanguage() };
 var src_default = {
 	meta: meta_exports,
+	languages,
 	configs,
 	rules,
 	resources
 };
 
 //#endregion
-export { configs, src_default as default, meta_exports as meta, resources, rules };
+export { configs, src_default as default, languages, meta_exports as meta, resources, rules };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -63,6 +63,16 @@
   },
   "dependencies": {
     "emoji-regex-xs": "^2.0.1",
+    "mdast-util-from-markdown": "^2.0.2",
+    "mdast-util-frontmatter": "^2.0.1",
+    "mdast-util-gfm": "^3.1.0",
+    "mdast-util-math": "^3.0.0",
+    "micromark-extension-frontmatter": "^2.0.0",
+    "micromark-extension-gfm": "^3.0.0",
+    "micromark-extension-math": "^3.1.0",
+    "micromark-factory-space": "^2.0.1",
+    "micromark-util-character": "^2.1.1",
+    "micromark-util-symbol": "^2.0.1",
     "string-width": "^8.0.0"
   },
   "devDependencies": {