@zinkawaii/eslint-plugin-markdown 0.0.0 → 8.0.3-patch.0

package/dist/rules-CjI0B_8H.mjs

@@ -0,0 +1,2357 @@
+import { createParser } from "satorigear";
+import { ConfigCommentParser, Directive, TextSourceCodeBase, VisitNodeStep } from "@eslint/plugin-kit";
+import { normalizeIdentifier } from "micromark-util-normalize-identifier";
+import GithubSlugger from "github-slugger";
+// vendor/src/processor.js
+/**
+* @fileoverview Processes Markdown files for consumption by ESLint.
+* @author Brandon Mills
+*/
+/**
+* @import { LintMessage, RuleTextEdit, SourceRange } from "@eslint/core";
+* @import { Node, Parent, Code, Html } from "mdast";
+* @import { Block, RangeMap } from "./types.js";
+*/
+const UNSATISFIABLE_RULES = /* @__PURE__ */ new Set(["eol-last", "unicode-bom"]);
+const SUPPORTS_AUTOFIX = true;
+const BOM = "";
+/**
+* @type {Map<string, Block[]>}
+*/
+const blocksCache = /* @__PURE__ */ new Map();
+/**
+* Performs a depth-first traversal of the Markdown AST.
+* @param {Node} node A Markdown AST node.
+* @param {{[key: string]: (() => void) | ((node: Code) => void) | ((node: Html) => void)}} callbacks A map of node types to callbacks.
+* @returns {void}
+*/
+function traverse(node, callbacks) {
+	if (callbacks[node.type])
+ /** @type {(node: Node) => void} */ callbacks[node.type](node);
+	else
+ /** @type {() => void} */ callbacks["*"]();
+	const parent = node;
+	if (typeof parent.children !== "undefined") for (let i = 0; i < parent.children.length; i++) traverse(parent.children[i], callbacks);
+}
+/**
+* Extracts `eslint-*` or `global` comments from HTML comments if present.
+* @param {string} html The text content of an HTML AST node.
+* @returns {string} The comment's text without the opening and closing tags or
+*     an empty string if the text is not an ESLint HTML comment.
+*/
+function getComment(html) {
+	const commentStart = "<!--";
+	const commentEnd = "-->";
+	const regex = /^(?:eslint\b|global\s)/u;
+	if (html.slice(0, 4) !== commentStart || html.slice(-3) !== commentEnd) return "";
+	const comment = html.slice(4, -3);
+	if (!regex.test(comment.trim())) return "";
+	return comment;
+}
+const leadingWhitespaceRegex = /^[>\s]*/u;
+/**
+* Gets the offset for the first column of the node's first line in the
+* original source text.
+* @param {Code} node A Markdown code block AST node.
+* @returns {number} The offset for the first column of the node's first line.
+*/
+function getBeginningOfLineOffset(node) {
+	return node.position.start.offset - node.position.start.column + 1;
+}
+/**
+* Gets the leading text, typically whitespace with possible blockquote chars,
+* used to indent a code block.
+* @param {string} text The text of the file.
+* @param {Code} node A Markdown code block AST node.
+* @returns {string} The text from the start of the first line to the opening
+*     fence of the code block.
+*/
+function getIndentText(text, node) {
+	return leadingWhitespaceRegex.exec(text.slice(getBeginningOfLineOffset(node)))[0];
+}
+/**
+* When applying fixes, the postprocess step needs to know how to map fix ranges
+* from their location in the linted JS to the original offset in the Markdown.
+* Configuration comments and indentation trimming both complicate this process.
+*
+* Configuration comments appear in the linted JS but not in the Markdown code
+* block. Fixes to configuration comments would cause undefined behavior and
+* should be ignored during postprocessing. Fixes to actual code after
+* configuration comments need to be mapped back to the code block after
+* removing any offset due to configuration comments.
+*
+* Fenced code blocks can be indented by up to three spaces at the opening
+* fence. Inside of a list, for example, this indent can be in addition to the
+* indent already required for list item children. Leading whitespace inside
+* indented code blocks is trimmed up to the level of the opening fence and does
+* not appear in the linted code. Further, lines can have less leading
+* whitespace than the opening fence, so not all lines are guaranteed to have
+* the same column offset as the opening fence.
+*
+* The source code of a non-configuration-comment line in the linted JS is a
+* suffix of the corresponding line in the Markdown code block. There are no
+* differences within the line, so the mapping need only provide the offset
+* delta at the beginning of each line.
+* @param {string} text The text of the file.
+* @param {Code} node A Markdown code block AST node.
+* @param {string[]} comments List of configuration comment strings that will be
+*     inserted at the beginning of the code block.
+* @returns {RangeMap[]} A list of offset-based adjustments, where lookups are
+*     done based on the `js` key, which represents the range in the linted JS,
+*     and the `md` key is the offset delta that, when added to the JS range,
+*     returns the corresponding location in the original Markdown source.
+*/
+function getBlockRangeMap(text, node, comments) {
+	const startOffset = getBeginningOfLineOffset(node);
+	const lines = text.slice(startOffset, node.position.end.offset).split("\n");
+	const baseIndent = getIndentText(text, node).length;
+	const commentLength = comments.reduce((len, comment) => len + comment.length + 1, 0);
+	const rangeMap = [{
+		indent: baseIndent,
+		js: 0,
+		md: 0
+	}];
+	let jsOffset = commentLength;
+	let mdOffset = startOffset + lines[0].length + 1;
+	for (let i = 0; i + 1 < lines.length; i++) {
+		const line = lines[i + 1];
+		const leadingWhitespaceLength = leadingWhitespaceRegex.exec(line)[0].length;
+		const trimLength = Math.min(baseIndent, leadingWhitespaceLength);
+		rangeMap.push({
+			indent: trimLength,
+			js: jsOffset,
+			md: mdOffset + trimLength - jsOffset
+		});
+		mdOffset += line.length + 1;
+		jsOffset += line.length - trimLength + 1;
+	}
+	return rangeMap;
+}
+const codeBlockFileNameRegex = /filename=(?<quote>["'])(?<filename>.*?)\1/u;
+/**
+* Parses the file name from a block meta, if available.
+* @param {Block} block A code block.
+* @returns {string | null | undefined} The filename, if parsed from block meta.
+*/
+function fileNameFromMeta(block) {
+	return block.meta?.match(codeBlockFileNameRegex)?.groups.filename.replaceAll(/\s+/gu, "_");
+}
+const languageToFileExtension = {
+	javascript: "js",
+	ecmascript: "js",
+	typescript: "ts",
+	markdown: "md"
+};
+const defaultParser = createParser();
+/**
+* Extracts lintable code blocks from Markdown text.
+* @param {string} sourceText The text of the file.
+* @param {string} filename The filename of the file.
+* @returns {Array<{ filename: string, text: string }>} Source code blocks to lint.
+*/
+function preprocess(sourceText, filename) {
+	const text = sourceText.startsWith(BOM) ? sourceText.slice(1) : sourceText;
+	const ast = defaultParser.parse(text);
+	/** @type {Block[]} */
+	const blocks = [];
+	blocksCache.set(filename, blocks);
+	/**
+	* During the depth-first traversal, keep track of any sequences of HTML
+	* comment nodes containing `eslint-*` or `global` comments. If a code
+	* block immediately follows such a sequence, insert the comments at the
+	* top of the code block. Any non-ESLint comment or other node type breaks
+	* and empties the sequence.
+	* @type {string[]}
+	*/
+	let htmlComments = [];
+	traverse(ast, {
+		"*"() {
+			htmlComments = [];
+		},
+		/**
+		* Visit a code node.
+		* @param {Code} node The visited node.
+		* @returns {void}
+		*/
+		code(node) {
+			if (node.lang) {
+				/** @type {string[]} */
+				const comments = [];
+				for (const comment of htmlComments) {
+					if (comment.trim() === "eslint-skip") {
+						htmlComments = [];
+						return;
+					}
+					comments.push(`/*${comment}*/`);
+				}
+				htmlComments = [];
+				blocks.push({
+					...node,
+					baseIndentText: getIndentText(text, node),
+					comments,
+					rangeMap: getBlockRangeMap(text, node, comments)
+				});
+			}
+		},
+		/**
+		* Visit an HTML node.
+		* @param {Html} node The visited node.
+		* @returns {void}
+		*/
+		html(node) {
+			const comment = getComment(node.value);
+			if (comment) htmlComments.push(comment);
+			else htmlComments = [];
+		}
+	});
+	return blocks.map((block, index) => {
+		const [language] = block.lang.trim().split(" ");
+		const fileExtension = Object.hasOwn(languageToFileExtension, language) ? languageToFileExtension[language] : language;
+		return {
+			filename: fileNameFromMeta(block) ?? `${index}.${fileExtension}`,
+			text: [
+				...block.comments,
+				block.value,
+				""
+			].join("\n")
+		};
+	});
+}
+/**
+* Adjusts a fix in a code block.
+* @param {Block} block A code block.
+* @param {RuleTextEdit} fix A fix to adjust.
+* @returns {RuleTextEdit} The fix with adjusted ranges.
+*/
+function adjustFix(block, fix) {
+	return {
+		range: fix.range.map((range) => {
+			let i = 1;
+			while (i < block.rangeMap.length && block.rangeMap[i].js <= range) i++;
+			return range + block.rangeMap[i - 1].md;
+		}),
+		text: fix.text.replace(/\n/gu, `\n${block.baseIndentText}`)
+	};
+}
+/**
+* Creates a map function that adjusts messages in a code block.
+* @param {Block} block A code block.
+* @returns {(message: LintMessage) => LintMessage | null} A function that adjusts messages in a code block.
+*/
+function adjustBlock(block) {
+	const leadingCommentLines = block.comments.reduce((count, comment) => count + comment.split("\n").length, 0);
+	const blockStart = block.position.start.line;
+	/**
+	* Adjusts ESLint messages to point to the correct location in the Markdown.
+	* @param {LintMessage} message A message from ESLint.
+	* @returns {LintMessage} The same message, but adjusted to the correct location.
+	*/
+	return function adjustMessage(message) {
+		if (!Number.isInteger(message.line)) return {
+			...message,
+			line: blockStart,
+			column: block.position.start.column
+		};
+		const lineInCode = message.line - leadingCommentLines;
+		if (lineInCode < 1 || lineInCode >= block.rangeMap.length) return null;
+		/** @type {Pick<LintMessage, "line" | "column" | "endLine" | "suggestions">} */
+		const out = {
+			line: lineInCode + blockStart,
+			column: message.column + block.rangeMap[lineInCode].indent
+		};
+		if (Number.isInteger(message.endLine)) out.endLine = message.endLine - leadingCommentLines + blockStart;
+		if (Array.isArray(message.suggestions)) out.suggestions = message.suggestions.map((suggestion) => ({
+			...suggestion,
+			fix: adjustFix(block, suggestion.fix)
+		}));
+		const adjustedFix = {};
+		if (message.fix) adjustedFix.fix = adjustFix(block, message.fix);
+		return {
+			...message,
+			...out,
+			...adjustedFix
+		};
+	};
+}
+/**
+* Excludes unsatisfiable rules from the list of messages.
+* @param {LintMessage} message A message from the linter.
+* @returns {boolean} True if the message should be included in output.
+*/
+function excludeUnsatisfiableRules(message) {
+	return message && !UNSATISFIABLE_RULES.has(message.ruleId);
+}
+/**
+* Transforms generated messages for output.
+* @param {Array<LintMessage[]>} messages An array containing one array of messages
+*     for each code block returned from `preprocess`.
+* @param {string} filename The filename of the file
+* @returns {LintMessage[]} A flattened array of messages with mapped locations.
+*/
+function postprocess(messages, filename) {
+	const blocks = blocksCache.get(filename);
+	blocksCache.delete(filename);
+	return messages.flatMap((group, i) => {
+		const adjust = adjustBlock(blocks[i]);
+		return group.map(adjust).filter(excludeUnsatisfiableRules);
+	});
+}
+const processor = {
+	meta: {
+		name: "@eslint/markdown/markdown",
+		version: "8.0.3"
+	},
+	preprocess,
+	postprocess,
+	supportsAutofix: SUPPORTS_AUTOFIX
+};
+// vendor/src/util.js
+/**
+* @fileoverview Utility Library
+* @author Nicholas C. Zakas
+*/
+/**
+* Line ending pattern to match all line endings (CRLF, CR, LF). (CommonMark spec)
+* @see https://spec.commonmark.org/0.31.2/#line-ending
+*/
+const lineEndingPattern = /\r\n|[\r\n]/u;
+/**
+* CommonMark does not allow any white space between the brackets in a reference link.
+* If that pattern is detected, then it's treated as text and not as a link. This pattern
+* is used to detect that situation.
+*/
+const illegalShorthandTailPattern = /\]\[\s+\]$/u;
+/**
+* Regular expression to match HTML comments, including multiline comments.
+*/
+const htmlCommentPattern = /<!--[\s\S]*?-->/gu;
+/**
+* Checks if a frontmatter block contains a title matching the given pattern.
+* @param {string} value The frontmatter content.
+* @param {RegExp|null} pattern The pattern to match against.
+* @returns {boolean} Whether a title was found.
+*/
+function frontmatterHasTitle(value, pattern) {
+	if (!pattern) return false;
+	const lines = value.split(lineEndingPattern);
+	for (const line of lines) if (pattern.test(line)) return true;
+	return false;
+}
+/**
+* Normalizes a Markdown reference identifier.
+* @param {string} identifier The identifier to normalize.
+* @returns {string} The normalized lowercase identifier.
+*/
+function normalizeIdentifier$1(identifier) {
+	return normalizeIdentifier(identifier).toLowerCase();
+}
+/**
+* Replaces all HTML comments with whitespace.
+* This preserves offsets and locations of characters
+* outside HTML comments by keeping line breaks and replacing
+* other code units with a space character.
+* @param {string} value The string to remove HTML comments from.
+* @returns {string} The string with HTML comments removed.
+*/
+function stripHtmlComments(value) {
+	return value.replace(htmlCommentPattern, (match) => match.replace(/[^\r\n]/g, " "));
+}
+// vendor/src/language/markdown-source-code.js
+/**
+* @fileoverview The MarkdownSourceCode class.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { Position } from "unist";
+* @import { Parent, Root, Node, Html } from "mdast";
+* @import { TraversalStep, FileProblem, DirectiveType, RulesConfig } from "@eslint/core";
+* @import { MarkdownLanguageOptions } from "../types.js";
+*/
+const commentParser = new ConfigCommentParser();
+const configCommentStart = /<!--\s*eslint(?:-enable|-disable(?:(?:-next)?-line)?)?(?:\s|-->)/u;
+const htmlComment = /<!--(.*?)-->/gsu;
+/**
+* Represents an inline config comment in the source code.
+*/
+var InlineConfigComment = class {
+	/**
+	* The comment text.
+	* @type {string}
+	*/
+	value;
+	/**
+	* The position of the comment in the source code.
+	* @type {Position}
+	*/
+	position;
+	/**
+	* Creates a new instance.
+	* @param {Object} options The options for the instance.
+	* @param {string} options.value The comment text.
+	* @param {Position} options.position The position of the comment in the source code.
+	*/
+	constructor({ value, position }) {
+		this.value = value.trim();
+		this.position = position;
+	}
+};
+/**
+* Extracts inline configuration comments from an HTML node.
+* @param {Html} node The HTML node to extract comments from.
+* @param {MarkdownSourceCode} sourceCode The Markdown source code object.
+* @returns {Array<InlineConfigComment>} The inline configuration comments found in the node.
+*/
+function extractInlineConfigCommentsFromHTML(node, sourceCode) {
+	if (!configCommentStart.test(node.value)) return [];
+	/** @type {Array<InlineConfigComment>} */
+	const comments = [];
+	/** @type {RegExpExecArray | null} */
+	let match;
+	while (match = htmlComment.exec(node.value)) if (configCommentStart.test(match[0])) {
+		const startOffset = match.index + node.position.start.offset;
+		const endOffset = startOffset + match[0].length;
+		comments.push(new InlineConfigComment({
+			value: match[1].trim(),
+			position: {
+				start: {
+					...sourceCode.getLocFromIndex(startOffset),
+					offset: startOffset
+				},
+				end: {
+					...sourceCode.getLocFromIndex(endOffset),
+					offset: endOffset
+				}
+			}
+		}));
+	}
+	return comments;
+}
+/**
+* Markdown Source Code Object
+* @extends {TextSourceCodeBase<{LangOptions: MarkdownLanguageOptions, RootNode: Root, SyntaxElementWithLoc: Node, ConfigNode: { value: string; position: Position }}>}
+*/
+var MarkdownSourceCode = class extends TextSourceCodeBase {
+	/**
+	* Cached traversal steps.
+	* @type {Array<VisitNodeStep>|undefined}
+	*/
+	#steps;
+	/**
+	* Cache of parent nodes.
+	* @type {WeakMap<Node, Parent|undefined>}
+	*/
+	#parents = /* @__PURE__ */ new WeakMap();
+	/**
+	* Collection of HTML nodes. Used to find directive comments.
+	* @type {Array<Html>}
+	*/
+	#htmlNodes = [];
+	/**
+	* Collection of inline configuration comments.
+	* @type {Array<InlineConfigComment>}
+	*/
+	#inlineConfigComments;
+	/**
+	* The AST of the source code.
+	* @type {Root}
+	*/
+	ast = void 0;
+	/**
+	* Creates a new instance.
+	* @param {Object} options The options for the instance.
+	* @param {string} options.text The source code text.
+	* @param {Root} options.ast The root AST node.
+	*/
+	constructor({ text, ast }) {
+		super({
+			ast,
+			text,
+			lineEndingPattern
+		});
+		this.ast = ast;
+		this.traverse();
+	}
+	/**
+	* Returns the parent of the given node.
+	* @param {Node} node The node to get the parent of.
+	* @returns {Parent|undefined} The parent of the node.
+	*/
+	getParent(node) {
+		return this.#parents.get(node);
+	}
+	/**
+	* Returns an array of all inline configuration nodes found in the
+	* source code.
+	* @returns {Array<InlineConfigComment>} An array of all inline configuration nodes.
+	*/
+	getInlineConfigNodes() {
+		if (!this.#inlineConfigComments) this.#inlineConfigComments = this.#htmlNodes.flatMap((htmlNode) => extractInlineConfigCommentsFromHTML(htmlNode, this));
+		return this.#inlineConfigComments;
+	}
+	/**
+	* Returns an all directive nodes that enable or disable rules along with any problems
+	* encountered while parsing the directives.
+	* @returns {{problems:Array<FileProblem>,directives:Array<Directive>}} Information
+	*      that ESLint needs to further process the directives.
+	*/
+	getDisableDirectives() {
+		/** @type {Array<FileProblem>} */
+		const problems = [];
+		/** @type {Array<Directive>} */
+		const directives = [];
+		this.getInlineConfigNodes().forEach((comment) => {
+			const { label, value, justification: justificationPart } = commentParser.parseDirective(comment.value);
+			if (label === "eslint-disable-line" && comment.position.start.line !== comment.position.end.line) {
+				const message = `${label} comment should not span multiple lines.`;
+				problems.push({
+					ruleId: null,
+					message,
+					loc: comment.position
+				});
+				return;
+			}
+			switch (label) {
+				case "eslint-disable":
+				case "eslint-enable":
+				case "eslint-disable-next-line":
+				case "eslint-disable-line": {
+					const directiveType = label.slice(7);
+					directives.push(new Directive({
+						type: directiveType,
+						node: comment,
+						value,
+						justification: justificationPart
+					}));
+				}
+			}
+		});
+		return {
+			problems,
+			directives
+		};
+	}
+	/**
+	* Returns inline rule configurations along with any problems
+	* encountered while parsing the configurations.
+	* @returns {{problems:Array<FileProblem>,configs:Array<{config:{rules:RulesConfig},loc:Position}>}} Information
+	*      that ESLint needs to further process the rule configurations.
+	*/
+	applyInlineConfig() {
+		/** @type {Array<FileProblem>} */
+		const problems = [];
+		/** @type {Array<{config:{rules:RulesConfig},loc:Position}>} */
+		const configs = [];
+		this.getInlineConfigNodes().forEach((comment) => {
+			const { label, value } = commentParser.parseDirective(comment.value);
+			if (label === "eslint") {
+				const parseResult = commentParser.parseJSONLikeConfig(value);
+				if (parseResult.ok) configs.push({
+					config: { rules: parseResult.config },
+					loc: comment.position
+				});
+				else problems.push({
+					ruleId: null,
+					message: 
+					/** @type {{ok: false, error: { message: string }}} */ parseResult.error.message,
+					loc: comment.position
+				});
+			}
+		});
+		return {
+			configs,
+			problems
+		};
+	}
+	/**
+	* Traverse the source code and return the steps that were taken.
+	* @returns {Iterable<TraversalStep>} The steps that were taken while traversing the source code.
+	*/
+	traverse() {
+		if (this.#steps) return this.#steps.values();
+		/** @type {Array<VisitNodeStep>} */
+		const steps = this.#steps = [];
+		/**
+		* Recursively visits a node and its children.
+		* @param {Node} node The node to visit.
+		* @param {Parent} [parent] The parent of the node.
+		* @returns {void}
+		*/
+		const visit = (node, parent) => {
+			this.#parents.set(node, parent);
+			steps.push(new VisitNodeStep({
+				target: node,
+				phase: 1,
+				args: [node, parent]
+			}));
+			if (node.type === "html") this.#htmlNodes.push(node);
+			if ("children" in node) {
+				const parentNode = node;
+				parentNode.children.forEach((child) => {
+					visit(child, parentNode);
+				});
+			}
+			steps.push(new VisitNodeStep({
+				target: node,
+				phase: 2,
+				args: [node, parent]
+			}));
+		};
+		visit(this.ast);
+		return steps.values();
+	}
+};
+// vendor/src/language/markdown-language.js
+/**
+* @fileoverview The MarkdownLanguage class.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { Language, File, ParseResult, OkParseResult } from "@eslint/core";
+* @import { Node, Root } from "mdast";
+* @import { Parser } from "satorigear";
+* @import { MarkdownLanguageOptions, MarkdownLanguageContext } from "../types.js";
+* @typedef {"commonmark"|"gfm"} ParserMode
+*/
+/**
+* The cache of parsers.
+* @type {Map<string, Parser>}
+*/
+const parsers = /* @__PURE__ */ new Map();
+/**
+* Create parser options based on `mode` and `languageOptions`.
+* @param {ParserMode} mode The markdown parser mode.
+* @param {MarkdownLanguageOptions} languageOptions Language options.
+* @returns {Parser} Satorigear parser.
+*/
+function createParser$1(mode, languageOptions) {
+	const key = [
+		mode,
+		languageOptions.frontmatter,
+		languageOptions.math
+	].join("+");
+	if (parsers.has(key)) return parsers.get(key);
+	const gfm = mode === "gfm";
+	const parser = createParser({ features: {
+		footnote: gfm,
+		frontmatter: languageOptions.frontmatter && { marker: languageOptions.frontmatter === "toml" ? "+" : "-" },
+		math: languageOptions.math,
+		strikethrough: gfm,
+		table: gfm,
+		taskList: gfm
+	} });
+	parsers.set(key, parser);
+	return parser;
+}
+/**
+* Markdown Language Object
+* @implements {Language<{ LangOptions: MarkdownLanguageOptions; Code: MarkdownSourceCode; RootNode: Root; Node: Node }>}
+*/
+var MarkdownLanguage = class {
+	/**
+	* The type of file to read.
+	* @type {"text"}
+	*/
+	fileType = "text";
+	/**
+	* The line number at which the parser starts counting.
+	* @type {0|1}
+	*/
+	lineStart = 1;
+	/**
+	* The column number at which the parser starts counting.
+	* @type {0|1}
+	*/
+	columnStart = 1;
+	/**
+	* The name of the key that holds the type of the node.
+	* @type {string}
+	*/
+	nodeTypeKey = "type";
+	/**
+	* Default language options. User-defined options are merged with this object.
+	* @type {MarkdownLanguageOptions}
+	*/
+	defaultLanguageOptions = {
+		frontmatter: false,
+		math: false
+	};
+	/**
+	* The Markdown parser mode.
+	* @type {ParserMode}
+	*/
+	#mode = "commonmark";
+	/**
+	* Creates a new instance.
+	* @param {Object} options The options to use for this instance.
+	* @param {ParserMode} [options.mode] The Markdown parser mode to use.
+	*/
+	constructor({ mode } = {}) {
+		if (mode) this.#mode = mode;
+	}
+	/**
+	* Validates the language options.
+	* @param {MarkdownLanguageOptions} languageOptions The language options to validate.
+	* @returns {void}
+	* @throws {Error} When the language options are invalid.
+	*/
+	validateLanguageOptions(languageOptions) {
+		const frontmatterOption = languageOptions?.frontmatter;
+		if (frontmatterOption !== void 0 && !(/* @__PURE__ */ new Set([
+			false,
+			"yaml",
+			"toml",
+			"json"
+		])).has(frontmatterOption)) throw new Error(`Invalid language option value \`${String(frontmatterOption)}\` for frontmatter. Expected one of \`false\`, \`"yaml"\`, \`"toml"\`, or \`"json"\`.`);
+		const mathOption = languageOptions?.math;
+		if (mathOption !== void 0 && typeof mathOption !== "boolean") throw new Error(`Invalid language option value \`${String(mathOption)}\` for math. Expected a boolean.`);
+	}
+	/**
+	* 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: createParser$1(this.#mode, context?.languageOptions).parse(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 new MarkdownSourceCode({
+			text: file.body,
+			ast: parseResult.ast
+		});
+	}
+};
+// vendor/src/rules/fenced-code-language.js
+/**
+* @fileoverview Rule to enforce languages for fenced code.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"missingLanguage" | "disallowedLanguage"} FencedCodeLanguageMessageIds
+* @typedef {[{ required?: string[] }]} FencedCodeLanguageOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: FencedCodeLanguageOptions, MessageIds: FencedCodeLanguageMessageIds }>} FencedCodeLanguageRuleDefinition
+*/
+const fencedCodeCharacters = /* @__PURE__ */ new Set(["`", "~"]);
+var fenced_code_language_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Require languages for fenced code blocks",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/fenced-code-language.md"
+		},
+		messages: {
+			missingLanguage: "Missing code block language.",
+			disallowedLanguage: "Code block language \"{{lang}}\" is not allowed."
+		},
+		schema: [{
+			type: "object",
+			properties: { required: {
+				type: "array",
+				items: { type: "string" },
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ required: [] }]
+	},
+	create(context) {
+		const required = new Set(context.options[0].required);
+		const { sourceCode } = context;
+		return { code(node) {
+			if (!node.lang) {
+				if (!fencedCodeCharacters.has(sourceCode.text[node.position.start.offset])) return;
+				/** @type {number} */
+				let openingCodeFenceEndOffset;
+				for (openingCodeFenceEndOffset = node.position.start.offset; fencedCodeCharacters.has(sourceCode.text[openingCodeFenceEndOffset]); openingCodeFenceEndOffset++);
+				context.report({
+					loc: {
+						start: node.position.start,
+						end: {
+							line: node.position.start.line,
+							column: node.position.start.column + openingCodeFenceEndOffset - node.position.start.offset
+						}
+					},
+					messageId: "missingLanguage"
+				});
+				return;
+			}
+			if (required.size && !required.has(node.lang)) {
+				const langIndex = sourceCode.getText(node).indexOf(node.lang);
+				context.report({
+					loc: {
+						start: node.position.start,
+						end: {
+							line: node.position.start.line,
+							column: node.position.start.column + langIndex + node.lang.length
+						}
+					},
+					messageId: "disallowedLanguage",
+					data: { lang: node.lang }
+				});
+			}
+		} };
+	}
+};
+// vendor/src/rules/fenced-code-meta.js
+/**
+* @fileoverview Rule to require or disallow metadata for fenced code blocks.
+* @author TKDev7
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"missingMetadata" | "disallowedMetadata"} FencedCodeMetaMessageIds
+* @typedef {["always" | "never"]} FencedCodeMetaOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: FencedCodeMetaOptions, MessageIds: FencedCodeMetaMessageIds }>} FencedCodeMetaRuleDefinition
+*/
+var fenced_code_meta_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: false,
+			description: "Require or disallow metadata for fenced code blocks",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/fenced-code-meta.md"
+		},
+		messages: {
+			missingMetadata: "Missing code block metadata.",
+			disallowedMetadata: "Code block metadata is not allowed."
+		},
+		schema: [{ enum: ["always", "never"] }],
+		defaultOptions: ["always"]
+	},
+	create(context) {
+		const [mode] = context.options;
+		const { sourceCode } = context;
+		return { code(node) {
+			const fenceLineText = sourceCode.lines[node.position.start.line - 1].slice(node.position.start.column - 1);
+			if (mode === "always") {
+				if (node.lang && !node.meta) {
+					const langIndex = fenceLineText.indexOf(node.lang);
+					context.report({
+						loc: {
+							start: node.position.start,
+							end: {
+								line: node.position.start.line,
+								column: node.position.start.column + langIndex + node.lang.length
+							}
+						},
+						messageId: "missingMetadata"
+					});
+				}
+				return;
+			}
+			if (node.meta) {
+				const metaIndex = fenceLineText.lastIndexOf(node.meta);
+				context.report({
+					loc: {
+						start: {
+							line: node.position.start.line,
+							column: node.position.start.column + metaIndex
+						},
+						end: {
+							line: node.position.start.line,
+							column: node.position.start.column + metaIndex + node.meta.trimEnd().length
+						}
+					},
+					messageId: "disallowedMetadata"
+				});
+			}
+		} };
+	}
+};
+// vendor/src/rules/heading-increment.js
+/**
+* @fileoverview Rule to enforce heading levels increment by one.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"skippedHeading"} HeadingIncrementMessageIds
+* @typedef {[{ frontmatterTitle?: string }]} HeadingIncrementOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: HeadingIncrementOptions, MessageIds: HeadingIncrementMessageIds }>} HeadingIncrementRuleDefinition
+*/
+var heading_increment_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Enforce heading levels increment by one",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/heading-increment.md"
+		},
+		messages: { skippedHeading: "Heading level skipped from {{fromLevel}} to {{toLevel}}." },
+		schema: [{
+			type: "object",
+			properties: { frontmatterTitle: { type: "string" } },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ frontmatterTitle: "^(?!\\s*['\"]title[:=]['\"])\\s*\\{?\\s*['\"]?title['\"]?\\s*[:=]" }]
+	},
+	create(context) {
+		const [{ frontmatterTitle }] = context.options;
+		const titlePattern = frontmatterTitle === "" ? null : new RegExp(frontmatterTitle, "iu");
+		let lastHeadingDepth = 0;
+		return {
+			yaml(node) {
+				if (frontmatterHasTitle(node.value, titlePattern)) lastHeadingDepth = 1;
+			},
+			toml(node) {
+				if (frontmatterHasTitle(node.value, titlePattern)) lastHeadingDepth = 1;
+			},
+			json(node) {
+				if (frontmatterHasTitle(node.value, titlePattern)) lastHeadingDepth = 1;
+			},
+			heading(node) {
+				if (lastHeadingDepth > 0 && node.depth > lastHeadingDepth + 1) context.report({
+					loc: node.position,
+					messageId: "skippedHeading",
+					data: {
+						fromLevel: lastHeadingDepth,
+						toLevel: node.depth
+					}
+				});
+				lastHeadingDepth = node.depth;
+			}
+		};
+	}
+};
+// vendor/src/rules/no-bare-urls.js
+/**
+* @fileoverview Rule to prevent bare URLs in Markdown.
+* @author xbinaryx
+*/
+/**
+* @import { Link, Html } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"bareUrl"} NoBareUrlsMessageIds
+* @typedef {[]} NoBareUrlsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoBareUrlsOptions, MessageIds: NoBareUrlsMessageIds }>} NoBareUrlsRuleDefinition
+*/
+const htmlTagNamePattern = /^<(?<tagName>[^!>][^/\s>]*)/u;
+const linkTextSpecialCharacterPattern = /[[\]\\*_~`$&|]/gu;
+const linkDestinationSpecialCharacterPattern = /[\\()&|]/gu;
+/**
+* Parses an HTML tag to extract its name and closing status
+* @param {string} tagText The HTML tag text to parse
+* @returns {{ name: string, isClosing: boolean } | null} Object containing tag name and closing status, or null if not a valid tag
+*/
+function parseHtmlTag(tagText) {
+	const match = tagText.match(htmlTagNamePattern);
+	if (match) {
+		const tagName = match.groups.tagName.toLowerCase();
+		const isClosing = tagName.startsWith("/");
+		return {
+			name: isClosing ? tagName.slice(1) : tagName,
+			isClosing
+		};
+	}
+	return null;
+}
+var no_bare_urls_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/gfm"],
+		docs: {
+			description: "Disallow bare URLs",
+			dialects: ["GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-bare-urls.md"
+		},
+		fixable: "code",
+		messages: { bareUrl: "Unexpected bare URL. Use autolink (<URL>) or link ([text](URL)) instead." }
+	},
+	create(context) {
+		const { sourceCode } = context;
+		/**
+		* This array is used to store all `Link` nodes for the final report.
+		* @type {Array<Link>}
+		*/
+		const linkNodes = [];
+		/**
+		* This array is used to store `Link` nodes that are estimated to be between opening and closing HTML tags.
+		* @type {Array<Link>}
+		*/
+		const tempLinkNodes = [];
+		/** @type {string | null} */
+		let lastTagName = null;
+		/**
+		* Resets `tempLinkNodes` and `lastTagName`
+		* @returns {void}
+		*/
+		function reset() {
+			tempLinkNodes.length = 0;
+			lastTagName = null;
+		}
+		return {
+			":matches(heading, paragraph, tableCell) html"(node) {
+				const tagInfo = parseHtmlTag(node.value);
+				if (!tagInfo) return;
+				if (!tagInfo.isClosing && lastTagName === null) lastTagName = tagInfo.name;
+				if (tagInfo.isClosing && lastTagName === tagInfo.name) reset();
+			},
+			":matches(heading, paragraph, tableCell) link"(node) {
+				if (lastTagName !== null) tempLinkNodes.push(node);
+				else linkNodes.push(node);
+			},
+			"heading:exit"() {
+				linkNodes.push(...tempLinkNodes);
+				reset();
+			},
+			"paragraph:exit"() {
+				linkNodes.push(...tempLinkNodes);
+				reset();
+			},
+			"tableCell:exit"() {
+				linkNodes.push(...tempLinkNodes);
+				reset();
+			},
+			"root:exit"() {
+				for (const linkNode of linkNodes) {
+					const text = sourceCode.getText(linkNode);
+					const { url } = linkNode;
+					if (url === text || url === `http://${text}` || url === `mailto:${text}`) context.report({
+						node: linkNode,
+						messageId: "bareUrl",
+						fix(fixer) {
+							if (url !== `http://${text}`) return fixer.replaceText(linkNode, `<${text}>`);
+							const escapedLinkText = text.replace(linkTextSpecialCharacterPattern, "\\$&");
+							const escapedLinkDestination = url.replace(linkDestinationSpecialCharacterPattern, "\\$&");
+							return fixer.replaceText(linkNode, `[${escapedLinkText}](${escapedLinkDestination})`);
+						}
+					});
+				}
+			}
+		};
+	}
+};
+// vendor/src/rules/no-duplicate-definitions.js
+/**
+* @fileoverview Rule to prevent duplicate definitions in Markdown.
+* @author 루밀LuMir(lumirlumir)
+*/
+/**
+* @import { Definition, FootnoteDefinition } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"duplicateDefinition" | "duplicateFootnoteDefinition"} NoDuplicateDefinitionsMessageIds
+* @typedef {[{ allowDefinitions?: string[], allowFootnoteDefinitions?: string[], checkFootnoteDefinitions?: boolean }]} NoDuplicateDefinitionsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoDuplicateDefinitionsOptions, MessageIds: NoDuplicateDefinitionsMessageIds }>} NoDuplicateDefinitionsRuleDefinition
+*/
+var no_duplicate_definitions_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow duplicate definitions",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-duplicate-definitions.md"
+		},
+		messages: {
+			duplicateDefinition: "Unexpected duplicate definition `{{ identifier }}` (label: `{{ label }}`) found. First defined at line {{ firstLine }} (label: `{{ firstLabel }}`).",
+			duplicateFootnoteDefinition: "Unexpected duplicate footnote definition `{{ identifier }}` (label: `{{ label }}`) found. First defined at line {{ firstLine }} (label: `{{ firstLabel }}`)."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				allowDefinitions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				allowFootnoteDefinitions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				checkFootnoteDefinitions: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		defaultOptions: [{
+			allowDefinitions: ["//"],
+			allowFootnoteDefinitions: [],
+			checkFootnoteDefinitions: true
+		}]
+	},
+	create(context) {
+		const allowDefinitions = new Set(context.options[0].allowDefinitions.map(normalizeIdentifier$1));
+		const allowFootnoteDefinitions = new Set(context.options[0].allowFootnoteDefinitions.map(normalizeIdentifier$1));
+		const [{ checkFootnoteDefinitions }] = context.options;
+		/** @type {Map<string, Definition>} */
+		const definitions = /* @__PURE__ */ new Map();
+		/** @type {Map<string, FootnoteDefinition>} */
+		const footnoteDefinitions = /* @__PURE__ */ new Map();
+		return {
+			definition(node) {
+				if (allowDefinitions.has(node.identifier)) return;
+				if (definitions.has(node.identifier)) {
+					const firstDefinitionNode = definitions.get(node.identifier);
+					context.report({
+						node,
+						messageId: "duplicateDefinition",
+						data: {
+							identifier: node.identifier,
+							label: node.label.trim(),
+							firstLine: firstDefinitionNode.position.start.line,
+							firstLabel: firstDefinitionNode.label.trim()
+						}
+					});
+				} else definitions.set(node.identifier, node);
+			},
+			footnoteDefinition(node) {
+				if (!checkFootnoteDefinitions || allowFootnoteDefinitions.has(node.identifier)) return;
+				if (footnoteDefinitions.has(node.identifier)) {
+					const firstFootnoteDefinitionNode = footnoteDefinitions.get(node.identifier);
+					context.report({
+						node,
+						messageId: "duplicateFootnoteDefinition",
+						data: {
+							identifier: node.identifier,
+							label: node.label,
+							firstLine: firstFootnoteDefinitionNode.position.start.line,
+							firstLabel: firstFootnoteDefinitionNode.label
+						}
+					});
+				} else footnoteDefinitions.set(node.identifier, node);
+			}
+		};
+	}
+};
+// vendor/src/rules/no-duplicate-headings.js
+/**
+* @fileoverview Rule to prevent duplicate headings in Markdown.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"duplicateHeading"} NoDuplicateHeadingsMessageIds
+* @typedef {[{ checkSiblingsOnly?: boolean }]} NoDuplicateHeadingsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoDuplicateHeadingsOptions, MessageIds: NoDuplicateHeadingsMessageIds }>} NoDuplicateHeadingsRuleDefinition
+*/
+var no_duplicate_headings_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			description: "Disallow duplicate headings in the same document",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-duplicate-headings.md"
+		},
+		messages: { duplicateHeading: "Duplicate heading \"{{text}}\" found." },
+		schema: [{
+			type: "object",
+			properties: { checkSiblingsOnly: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ checkSiblingsOnly: false }]
+	},
+	create(context) {
+		const [{ checkSiblingsOnly }] = context.options;
+		/** @type {Map<number, Set<string>>} */
+		const headingsByLevel = checkSiblingsOnly ? /* @__PURE__ */ new Map([
+			[1, /* @__PURE__ */ new Set()],
+			[2, /* @__PURE__ */ new Set()],
+			[3, /* @__PURE__ */ new Set()],
+			[4, /* @__PURE__ */ new Set()],
+			[5, /* @__PURE__ */ new Set()],
+			[6, /* @__PURE__ */ new Set()]
+		]) : /* @__PURE__ */ new Map([[1, /* @__PURE__ */ new Set()]]);
+		let lastLevel = 1;
+		let currentLevelHeadings = headingsByLevel.get(lastLevel);
+		/** @type {string} */
+		let headingChildrenSequence;
+		/** @type {string} */
+		let headingText;
+		return {
+			heading(node) {
+				headingChildrenSequence = "";
+				headingText = "";
+				if (checkSiblingsOnly) {
+					const currentLevel = node.depth;
+					if (currentLevel < lastLevel) for (let level = lastLevel; level > currentLevel; level--) headingsByLevel.get(level).clear();
+					lastLevel = currentLevel;
+					currentLevelHeadings = headingsByLevel.get(currentLevel);
+				}
+			},
+			"heading *"({ type, value }) {
+				if (value) {
+					headingChildrenSequence += `[${type},${value}]`;
+					if (type !== "html") headingText += value;
+				} else headingChildrenSequence += `[${type}]`;
+			},
+			"heading:exit"(node) {
+				if (currentLevelHeadings.has(headingChildrenSequence)) context.report({
+					loc: node.position,
+					messageId: "duplicateHeading",
+					data: { text: headingText }
+				});
+				else currentLevelHeadings.add(headingChildrenSequence);
+			}
+		};
+	}
+};
+// vendor/src/rules/no-empty-definitions.js
+/**
+* @fileoverview Rule to prevent empty definitions in Markdown.
+* @author Pixel998
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"emptyDefinition" | "emptyFootnoteDefinition"} NoEmptyDefinitionsMessageIds
+* @typedef {[{ allowDefinitions?: string[], allowFootnoteDefinitions?: string[], checkFootnoteDefinitions?: boolean }]} NoEmptyDefinitionsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoEmptyDefinitionsOptions, MessageIds: NoEmptyDefinitionsMessageIds }>} NoEmptyDefinitionsRuleDefinition
+*/
+/**
+* Checks if a string contains only HTML comments.
+* @param {string} value The input string to check.
+* @returns {boolean} True if the string contains only HTML comments, false otherwise.
+*/
+function isOnlyComments(value) {
+	return value.replace(htmlCommentPattern, "").trim().length === 0;
+}
+var no_empty_definitions_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow empty definitions",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-empty-definitions.md"
+		},
+		messages: {
+			emptyDefinition: "Unexpected empty definition `{{ identifier }}` (label: `{{ label }}`) found.",
+			emptyFootnoteDefinition: "Unexpected empty footnote definition `{{ identifier }}` (label: `{{ label }}`) found."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				allowDefinitions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				allowFootnoteDefinitions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				checkFootnoteDefinitions: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		defaultOptions: [{
+			allowDefinitions: ["//"],
+			allowFootnoteDefinitions: [],
+			checkFootnoteDefinitions: true
+		}]
+	},
+	create(context) {
+		const allowDefinitions = new Set(context.options[0].allowDefinitions.map(normalizeIdentifier$1));
+		const allowFootnoteDefinitions = new Set(context.options[0].allowFootnoteDefinitions.map(normalizeIdentifier$1));
+		const [{ checkFootnoteDefinitions }] = context.options;
+		return {
+			definition(node) {
+				if ((!node.url || node.url === "#") && !allowDefinitions.has(node.identifier)) context.report({
+					loc: node.position,
+					messageId: "emptyDefinition",
+					data: {
+						identifier: node.identifier,
+						label: node.label.trim()
+					}
+				});
+			},
+			footnoteDefinition(node) {
+				if (checkFootnoteDefinitions && !allowFootnoteDefinitions.has(node.identifier) && (node.children.length === 0 || node.children.every((child) => child.type === "html" && isOnlyComments(child.value)))) context.report({
+					loc: node.position,
+					messageId: "emptyFootnoteDefinition",
+					data: {
+						identifier: node.identifier,
+						label: node.label
+					}
+				});
+			}
+		};
+	}
+};
+// vendor/src/rules/no-empty-images.js
+/**
+* @fileoverview Rule to prevent empty images in Markdown.
+* @author 루밀LuMir(lumirlumir)
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"emptyImage"} NoEmptyImagesMessageIds
+* @typedef {[]} NoEmptyImagesOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoEmptyImagesOptions, MessageIds: NoEmptyImagesMessageIds }>} NoEmptyImagesRuleDefinition
+*/
+var no_empty_images_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow empty images",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-empty-images.md"
+		},
+		messages: { emptyImage: "Unexpected empty image found." }
+	},
+	create(context) {
+		return { image(node) {
+			if (!node.url || node.url === "#") context.report({
+				loc: node.position,
+				messageId: "emptyImage"
+			});
+		} };
+	}
+};
+// vendor/src/rules/no-empty-links.js
+/**
+* @fileoverview Rule to prevent empty links in Markdown.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"emptyLink"} NoEmptyLinksMessageIds
+* @typedef {[]} NoEmptyLinksOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoEmptyLinksOptions, MessageIds: NoEmptyLinksMessageIds }>} NoEmptyLinksRuleDefinition
+*/
+var no_empty_links_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow empty links",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-empty-links.md"
+		},
+		messages: { emptyLink: "Unexpected empty link found." }
+	},
+	create(context) {
+		return { link(node) {
+			if (!node.url || node.url === "#") context.report({
+				loc: node.position,
+				messageId: "emptyLink"
+			});
+		} };
+	}
+};
+// vendor/src/rules/no-html.js
+/**
+* @fileoverview Rule to disallow HTML inside of content.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"disallowedElement"} NoHtmlMessageIds
+* @typedef {[{ allowed?: string[], allowedIgnoreCase?: boolean }]} NoHtmlOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoHtmlOptions, MessageIds: NoHtmlMessageIds }>} NoHtmlRuleDefinition
+*/
+const htmlTagPattern$1 = /<(?<tagName>[a-z0-9]+(?:-[a-z0-9]+)*)(?:\s(?:[^>"']|"[^"]*"|'[^']*')*)?\/?>/giu;
+var no_html_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			description: "Disallow HTML tags",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-html.md"
+		},
+		messages: { disallowedElement: "HTML element \"{{name}}\" is not allowed." },
+		schema: [{
+			type: "object",
+			properties: {
+				allowed: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				allowedIgnoreCase: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		defaultOptions: [{
+			allowed: [],
+			allowedIgnoreCase: false
+		}]
+	},
+	create(context) {
+		const { sourceCode } = context;
+		const [{ allowed, allowedIgnoreCase }] = context.options;
+		/**
+		* Normalize a tag name based on the `allowedIgnoreCase` option.
+		* @param {string} tagName The tag name to normalize.
+		* @returns {string} The normalized tag name.
+		*/
+		function normalizeTagName(tagName) {
+			return allowedIgnoreCase ? tagName.toLowerCase() : tagName;
+		}
+		const allowedElements = new Set(allowed.map(normalizeTagName));
+		return { html(node) {
+			const text = stripHtmlComments(sourceCode.getText(node));
+			/** @type {RegExpExecArray | null} */
+			let match;
+			while ((match = htmlTagPattern$1.exec(text)) !== null) {
+				const fullMatch = match[0];
+				const { tagName } = match.groups;
+				const firstNewlineIndex = fullMatch.search(lineEndingPattern);
+				const startOffset = match.index + node.position.start.offset;
+				const endOffset = startOffset + (firstNewlineIndex === -1 ? fullMatch.length : firstNewlineIndex);
+				if (!allowedElements.has(normalizeTagName(tagName))) context.report({
+					loc: {
+						start: sourceCode.getLocFromIndex(startOffset),
+						end: sourceCode.getLocFromIndex(endOffset)
+					},
+					messageId: "disallowedElement",
+					data: { name: tagName }
+				});
+			}
+		} };
+	}
+};
+// vendor/src/rules/no-invalid-label-refs.js
+/**
+* @fileoverview Rule to prevent non-complaint link references.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { Position } from "unist";
+* @import { Text } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @import { MarkdownSourceCode } from "../language/markdown-source-code.js";
+* @typedef {"invalidLabelRef"} NoInvalidLabelRefsMessageIds
+* @typedef {[]} NoInvalidLabelRefsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoInvalidLabelRefsOptions, MessageIds: NoInvalidLabelRefsMessageIds }>} NoInvalidLabelRefsRuleDefinition
+*/
+/** matches i.e., `[foo][bar]` */
+const labelPattern = /\]\[([^\]]+)\]/u;
+/**
+* Finds missing references in a node.
+* @param {Text} node The node to check.
+* @param {MarkdownSourceCode} sourceCode The Markdown source code object.
+* @returns {Array<{label:string,position:Position}>} The missing references.
+*/
+function findInvalidLabelReferences(node, sourceCode) {
+	const nodeText = sourceCode.getText(node);
+	const docText = sourceCode.text;
+	const invalid = [];
+	let startIndex = 0;
+	while (startIndex < nodeText.length) {
+		const match = nodeText.slice(startIndex).match(labelPattern);
+		if (!match) break;
+		if (!illegalShorthandTailPattern.test(match[0])) {
+			startIndex += match.index + match[0].length;
+			continue;
+		}
+		const startOffset = startIndex + match.index + node.position.start.offset;
+		const endOffset = startOffset + match[0].length;
+		const lastOpenBracketIndex = docText.lastIndexOf("[", startOffset);
+		if (lastOpenBracketIndex === -1) {
+			startIndex += match.index + match[0].length;
+			continue;
+		}
+		const label = docText.slice(lastOpenBracketIndex, endOffset).match(/!?\[([^\]]+)\]/u)[1];
+		invalid.push({
+			label: label.trim(),
+			position: {
+				start: sourceCode.getLocFromIndex(startOffset + 1),
+				end: sourceCode.getLocFromIndex(endOffset)
+			}
+		});
+		startIndex += match.index + match[0].length;
+	}
+	return invalid;
+}
+var no_invalid_label_refs_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow invalid label references",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-invalid-label-refs.md"
+		},
+		messages: { invalidLabelRef: "Label reference '{{label}}' is invalid due to white space between [ and ]." }
+	},
+	create(context) {
+		const { sourceCode } = context;
+		return { text(node) {
+			const invalidReferences = findInvalidLabelReferences(node, sourceCode);
+			for (const invalidReference of invalidReferences) context.report({
+				loc: invalidReference.position,
+				messageId: "invalidLabelRef",
+				data: { label: invalidReference.label }
+			});
+		} };
+	}
+};
+// vendor/src/rules/no-missing-atx-heading-space.js
+/**
+* @fileoverview Rule to ensure there is a space after hash on ATX style headings in Markdown.
+* @author Sweta Tanwar (@SwetaTanwar)
+*/
+/**
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"missingSpace"} NoMissingAtxHeadingSpaceMessageIds
+* @typedef {[{ checkClosedHeadings?: boolean }]} NoMissingAtxHeadingSpaceOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoMissingAtxHeadingSpaceOptions, MessageIds: NoMissingAtxHeadingSpaceMessageIds }>} NoMissingAtxHeadingSpaceRuleDefinition
+*/
+const leadingAtxHeadingHashPattern = /(?:^|(?<=[\r\n]))(?<hashes>#{1,6})(?:[^# \t]|$)/gu;
+const trailingAtxHeadingHashPattern = /(?<![ \t])(?<spaces>[ \t]*)(?<=(?<!\\)(?:\\{2})*)(?<hashes>#+)[ \t]*$/u;
+var no_missing_atx_heading_space_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow headings without a space after the hash characters",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-missing-atx-heading-space.md"
+		},
+		fixable: "whitespace",
+		messages: { missingSpace: "Missing space {{position}} hash(es) on ATX style heading." },
+		schema: [{
+			type: "object",
+			properties: { checkClosedHeadings: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ checkClosedHeadings: false }]
+	},
+	create(context) {
+		const { sourceCode } = context;
+		const [{ checkClosedHeadings }] = context.options;
+		return {
+			heading(node) {
+				if (!checkClosedHeadings) return;
+				const text = sourceCode.getText(node);
+				const match = trailingAtxHeadingHashPattern.exec(text);
+				if (match === null || match.index === 0) return;
+				const { spaces, hashes } = match.groups;
+				if (spaces.length > 0) return;
+				const startOffset = node.position.start.offset + match.index;
+				const endOffset = startOffset + hashes.length;
+				context.report({
+					loc: {
+						start: sourceCode.getLocFromIndex(startOffset - 1),
+						end: sourceCode.getLocFromIndex(endOffset)
+					},
+					messageId: "missingSpace",
+					data: { position: "before" },
+					fix(fixer) {
+						return fixer.insertTextBeforeRange([startOffset, startOffset + 1], " ");
+					}
+				});
+			},
+			paragraph(node) {
+				const text = sourceCode.getText(node);
+				/** @type {RegExpExecArray | null} */
+				let match;
+				while ((match = leadingAtxHeadingHashPattern.exec(text)) !== null) {
+					const { hashes } = match.groups;
+					const startOffset = node.position.start.offset + match.index;
+					const endOffset = startOffset + hashes.length;
+					context.report({
+						loc: {
+							start: sourceCode.getLocFromIndex(startOffset),
+							end: sourceCode.getLocFromIndex(endOffset + 1)
+						},
+						messageId: "missingSpace",
+						data: { position: "after" },
+						fix(fixer) {
+							return fixer.insertTextAfterRange([endOffset - 1, endOffset], " ");
+						}
+					});
+				}
+			}
+		};
+	}
+};
+// vendor/src/rules/no-missing-label-refs.js
+/**
+* @fileoverview Rule to prevent missing label references in Markdown.
+* @author Nicholas C. Zakas
+*/
+/**
+* @import { Position } from "unist";
+* @import { Text } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @import { MarkdownSourceCode } from "../language/markdown-source-code.js";
+* @typedef {"notFound"} NoMissingLabelRefsMessageIds
+* @typedef {[{ allowLabels?: string[] }]} NoMissingLabelRefsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoMissingLabelRefsOptions, MessageIds: NoMissingLabelRefsMessageIds }>} NoMissingLabelRefsRuleDefinition
+*/
+/**
+* Finds missing references in a node.
+* @param {Text} node The node to check.
+* @param {MarkdownSourceCode} sourceCode The Markdown source code object.
+* @returns {Array<{label:string,position:Position}>} The missing references.
+*/
+function findMissingReferences(node, sourceCode) {
+	/** @type {Array<{label:string,position:Position}>} */
+	const missing = [];
+	const nodeText = sourceCode.getText(node);
+	/**
+	* Matches substrings like `"[foo]"`, `"[]"`, `"[foo][bar]"`, `"[foo][]"`, `"[][bar]"`, or `"[][]"`.
+	* `left` is the content between the first brackets. It can be empty.
+	* `right` is the content between the second brackets. It can be empty, and it can be undefined.
+	*/
+	const labelPattern = /(?<=(?<!\\)(?:\\{2})*)\[(?<left>(?:\\.|[^[\]\\])*)\](?:\[(?<right>(?:\\.|[^\]\\])*)\])?/dgu;
+	/** @type {RegExpExecArray | null} */
+	let match;
+	while (match = labelPattern.exec(nodeText)) {
+		if (illegalShorthandTailPattern.test(match[0])) continue;
+		const { left, right } = match.groups;
+		if (!left && !right) continue;
+		let label, labelIndices;
+		if (right) {
+			label = right;
+			labelIndices = match.indices.groups.right;
+		} else {
+			label = left;
+			labelIndices = match.indices.groups.left;
+		}
+		const startOffset = labelIndices[0] + node.position.start.offset;
+		const endOffset = labelIndices[1] + node.position.start.offset;
+		missing.push({
+			label: label.trim(),
+			position: {
+				start: sourceCode.getLocFromIndex(startOffset),
+				end: sourceCode.getLocFromIndex(endOffset)
+			}
+		});
+	}
+	return missing;
+}
+var no_missing_label_refs_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow missing label references",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-missing-label-refs.md"
+		},
+		schema: [{
+			type: "object",
+			properties: { allowLabels: {
+				type: "array",
+				items: { type: "string" },
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ allowLabels: [] }],
+		messages: { notFound: "Label reference '{{label}}' not found." }
+	},
+	create(context) {
+		const { sourceCode } = context;
+		const allowLabels = new Set(context.options[0].allowLabels);
+		/** @type {Array<{label:string,position:Position}>} */
+		let allMissingReferences = [];
+		return {
+			"root:exit"() {
+				for (const missingReference of allMissingReferences) context.report({
+					loc: missingReference.position,
+					messageId: "notFound",
+					data: { label: missingReference.label }
+				});
+			},
+			text(node) {
+				const missingReferences = findMissingReferences(node, sourceCode);
+				for (const missingReference of missingReferences) if (!allowLabels.has(missingReference.label)) allMissingReferences.push(missingReference);
+			},
+			definition(node) {
+				allMissingReferences = allMissingReferences.filter((missingReference) => missingReference.label !== node.identifier);
+			}
+		};
+	}
+};
+// vendor/src/rules/no-missing-link-fragments.js
+/**
+* @fileoverview Rule to ensure link fragments (URLs that start with #) reference valid headings
+* @author Sweta Tanwar (@SwetaTanwar)
+*/
+/**
+* @import { Definition, Link } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"invalidFragment"} NoMissingLinkFragmentsMessageIds
+* @typedef {[{ ignoreCase?: boolean; allowPattern?: string }]} NoMissingLinkFragmentsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoMissingLinkFragmentsOptions, MessageIds: NoMissingLinkFragmentsMessageIds }>} NoMissingLinkFragmentsRuleDefinition
+*/
+const githubLineReferencePattern = /^L\d+(?:C\d+)?(?:-L\d+(?:C\d+)?)?$/u;
+const customHeadingIdPattern = /\{#(?<id>[^}\s]+)\}\s*$/u;
+const htmlHeadingPattern = /<h(?<depth>[1-6])[^>]*>(?<children>[\s\S]*?)<\/h\k<depth>\s*>/giu;
+const htmlIdNamePattern = /(?<!<)<[^>]+\s(?:id|name)\s*=\s*["']?(?<id>[^"'\s>]+)["']?/giu;
+const htmlTagPattern = /<\/?[a-z0-9]+(?:-[a-z0-9]+)*(?:\s(?:[^>"']|"[^"]*"|'[^']*')*)?(?:\/\s*)?>/giu;
+var no_missing_link_fragments_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow link fragments that do not reference valid headings",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-missing-link-fragments.md"
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				ignoreCase: { type: "boolean" },
+				allowPattern: { type: "string" }
+			},
+			additionalProperties: false
+		}],
+		messages: { invalidFragment: "Link fragment '#{{fragment}}' does not reference a heading or anchor in this document." },
+		defaultOptions: [{
+			ignoreCase: true,
+			allowPattern: ""
+		}]
+	},
+	create(context) {
+		const [{ allowPattern, ignoreCase }] = context.options;
+		const allowPatternOrNull = allowPattern ? new RegExp(allowPattern, "u") : null;
+		const fragmentIds = /* @__PURE__ */ new Set(["top"]);
+		const slugger = new GithubSlugger();
+		/** @type {Array<Definition | Link>} */
+		const relevantNodes = [];
+		/** @type {string} */
+		let headingText;
+		return {
+			heading() {
+				headingText = "";
+			},
+			"heading *:not(html)"({ value }) {
+				headingText += value ?? "";
+			},
+			"heading:exit"() {
+				const customIdMatch = headingText.match(customHeadingIdPattern);
+				const id = customIdMatch ? customIdMatch.groups.id : headingText;
+				fragmentIds.add(slugger.slug(id));
+			},
+			html(node) {
+				const htmlTextWithoutComments = stripHtmlComments(node.value);
+				for (const match of htmlTextWithoutComments.matchAll(htmlIdNamePattern)) {
+					const { id } = match.groups;
+					fragmentIds.add(slugger.slug(id));
+				}
+				for (const match of htmlTextWithoutComments.matchAll(htmlHeadingPattern)) {
+					const { children } = match.groups;
+					const id = children.replace(htmlTagPattern, "");
+					fragmentIds.add(slugger.slug(id));
+				}
+			},
+			"definition, link"(node) {
+				const { url } = node;
+				if (url === "" || url === "#" || !url.startsWith("#")) return;
+				relevantNodes.push(node);
+			},
+			"root:exit"() {
+				for (const node of relevantNodes) {
+					const fragment = node.url.slice(1);
+					let decodedFragment = fragment;
+					try {
+						decodedFragment = decodeURIComponent(fragment);
+					} catch {}
+					if (allowPatternOrNull?.test(decodedFragment) || githubLineReferencePattern.test(decodedFragment)) continue;
+					const normalizedFragment = ignoreCase ? decodedFragment.toLowerCase() : decodedFragment;
+					if (!fragmentIds.has(normalizedFragment)) context.report({
+						loc: node.position,
+						messageId: "invalidFragment",
+						data: { fragment }
+					});
+				}
+			}
+		};
+	}
+};
+// vendor/src/rules/no-multiple-h1.js
+/**
+* @fileoverview Rule to enforce at most one H1 heading in Markdown.
+* @author Pixel998
+*/
+/**
+* @import { Yaml } from "mdast";
+* @import { MarkdownRuleDefinition, Toml, Json } from "../types.js";
+* @typedef {"multipleH1"} NoMultipleH1MessageIds
+* @typedef {[{ frontmatterTitle?: string }]} NoMultipleH1Options
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoMultipleH1Options, MessageIds: NoMultipleH1MessageIds }>} NoMultipleH1RuleDefinition
+*/
+const h1TagPattern = /<h1[^>]*>[\s\S]*?<\/h1\s*>/giu;
+var no_multiple_h1_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow multiple H1 headings in the same document",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-multiple-h1.md"
+		},
+		messages: { multipleH1: "Unexpected additional H1 heading found." },
+		schema: [{
+			type: "object",
+			properties: { frontmatterTitle: { type: "string" } },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ frontmatterTitle: "^(?!\\s*['\"]title[:=]['\"])\\s*\\{?\\s*['\"]?title['\"]?\\s*[:=]" }]
+	},
+	create(context) {
+		const { sourceCode } = context;
+		const [{ frontmatterTitle }] = context.options;
+		const titlePattern = frontmatterTitle === "" ? null : new RegExp(frontmatterTitle, "iu");
+		let h1Count = 0;
+		return {
+			"yaml, toml, json"(node) {
+				if (frontmatterHasTitle(node.value, titlePattern)) h1Count++;
+			},
+			html(node) {
+				const text = stripHtmlComments(node.value);
+				/** @type {RegExpExecArray | null} */
+				let match;
+				while ((match = h1TagPattern.exec(text)) !== null) {
+					h1Count++;
+					if (h1Count > 1) {
+						const startOffset = match.index + node.position.start.offset;
+						const endOffset = startOffset + match[0].length;
+						context.report({
+							loc: {
+								start: sourceCode.getLocFromIndex(startOffset),
+								end: sourceCode.getLocFromIndex(endOffset)
+							},
+							messageId: "multipleH1"
+						});
+					}
+				}
+			},
+			heading(node) {
+				if (node.depth === 1) {
+					h1Count++;
+					if (h1Count > 1) context.report({
+						loc: node.position,
+						messageId: "multipleH1"
+					});
+				}
+			}
+		};
+	}
+};
+// vendor/src/rules/no-reference-like-urls.js
+/**
+* @fileoverview Rule to enforce reference-style links when URL matches a defined identifier.
+* @author TKDev7
+*/
+/**
+* @import { Image, Link } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"referenceLikeUrl"} NoReferenceLikeUrlsMessageIds
+* @typedef {[]} NoReferenceLikeUrlsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoReferenceLikeUrlsOptions, MessageIds: NoReferenceLikeUrlsMessageIds }>} NoReferenceLikeUrlsRuleDefinition
+*/
+/**
+* Pattern to match both inline links: `[text](url)` and images: `![alt](url)`, with optional title.
+* The nested group is `\((?:\\[\s\S]|[^()\\])*\)`, not `\([\s\S]*\)`, so that it cannot overlap the
+* other alternatives. Overlapping alternatives cause catastrophic backtracking.
+*/
+const linkOrImagePattern = /^!?\[(?<label>(?:\\.|[^()\\]|\((?:\\[\s\S]|[^()\\])*\))*?)\]\((?<destination>[ \t]*\r?\n?(?<![ \t])[ \t]*(?:<[^>]*>|[^ \t()]+))(?:[ \t]*\r?\n?(?<![ \t])[ \t]*(?:"[^"]*"|'[^']*'|\([^)]*\)))?[ \t]*\r?\n?(?<![ \t])[ \t]*\)$/u;
+var no_reference_like_urls_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow URLs that match defined reference identifiers",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-reference-like-urls.md"
+		},
+		fixable: "code",
+		messages: { referenceLikeUrl: "Unexpected resource {{type}} ('{{prefix}}[text](url)') with URL that matches a definition identifier. Use '[text][id]' syntax instead." }
+	},
+	create(context) {
+		const { sourceCode } = context;
+		/** @type {Set<string>} */
+		const definitionIdentifiers = /* @__PURE__ */ new Set();
+		/** @type {Array<Image | Link>} */
+		const relevantNodes = [];
+		return {
+			definition(node) {
+				definitionIdentifiers.add(node.identifier);
+			},
+			"image, link"(node) {
+				relevantNodes.push(node);
+			},
+			"root:exit"() {
+				for (const node of relevantNodes) {
+					const text = sourceCode.getText(node);
+					const match = linkOrImagePattern.exec(text);
+					if (match !== null) {
+						const { label, destination } = match.groups;
+						const { type, title } = node;
+						const prefix = type === "image" ? "!" : "";
+						const url = normalizeIdentifier$1(destination);
+						if (definitionIdentifiers.has(url)) context.report({
+							loc: node.position,
+							messageId: "referenceLikeUrl",
+							data: {
+								type,
+								prefix
+							},
+							fix(fixer) {
+								if (title) return null;
+								return fixer.replaceText(node, `${prefix}[${label}][${destination}]`);
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};
+// vendor/src/rules/no-reversed-media-syntax.js
+/**
+* @fileoverview Rule to prevent reversed link and image syntax in Markdown.
+* @author xbinaryx
+*/
+/**
+* @import { Heading, Paragraph, TableCell, FootnoteReference, Html, Image, ImageReference, InlineCode, LinkReference } from "mdast";
+* @import { InlineMath } from "satorigear";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"reversedSyntax"} NoReversedMediaSyntaxMessageIds
+* @typedef {[]} NoReversedMediaSyntaxOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoReversedMediaSyntaxOptions, MessageIds: NoReversedMediaSyntaxMessageIds }>} NoReversedMediaSyntaxRuleDefinition
+*/
+/**
+* Matches reversed link/image syntax like `(text)[url]`, ignoring escaped characters like `\(text\)[url]`.
+* The nested group is `\((?:\\[\s\S]|[^()\\])*\)`, not `\([\s\S]*\)`, so that it cannot overlap the
+* other alternatives. Overlapping alternatives cause catastrophic backtracking.
+*/
+const reversedPattern = /(?<=(?<!\\)(?:\\{2})*)\((?<label>(?:\\.|[^()\\]|\((?:\\[\s\S]|[^()\\])*\))*)\)\[(?<url>(?:\\.|[^\]\\\r\n])*)\](?!\()/gu;
+var no_reversed_media_syntax_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow reversed link and image syntax",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-reversed-media-syntax.md"
+		},
+		fixable: "code",
+		messages: { reversedSyntax: "Unexpected reversed syntax found. Use [label](URL) syntax instead." }
+	},
+	create(context) {
+		const { sourceCode } = context;
+		/** @type {string[]} */
+		let buffer;
+		/** @type {number} */
+		let nodeStartOffset;
+		return {
+			"heading, paragraph, tableCell"(node) {
+				buffer = sourceCode.getText(node).split("");
+				nodeStartOffset = node.position.start.offset;
+			},
+			":matches(heading, paragraph, tableCell) :matches(footnoteReference, html, image, imageReference, inlineCode, linkReference, inlineMath)"(node) {
+				const [startOffset, endOffset] = sourceCode.getRange(node);
+				for (let i = startOffset; i < endOffset; i++) buffer[i - nodeStartOffset] = " ";
+			},
+			":matches(heading, paragraph, tableCell):exit"() {
+				const maskedText = buffer.join("");
+				/** @type {RegExpExecArray | null} */
+				let match;
+				while ((match = reversedPattern.exec(maskedText)) !== null) {
+					const { label, url } = match.groups;
+					const startOffset = match.index + nodeStartOffset;
+					const endOffset = startOffset + match[0].length;
+					const labelStartOffset = startOffset + 1;
+					const labelEndOffset = labelStartOffset + label.length;
+					const urlStartOffset = labelEndOffset + 2;
+					const urlEndOffset = urlStartOffset + url.length;
+					context.report({
+						loc: {
+							start: sourceCode.getLocFromIndex(startOffset),
+							end: sourceCode.getLocFromIndex(endOffset)
+						},
+						messageId: "reversedSyntax",
+						fix(fixer) {
+							return fixer.replaceTextRange([startOffset, endOffset], `[${sourceCode.text.slice(labelStartOffset, labelEndOffset)}](${sourceCode.text.slice(urlStartOffset, urlEndOffset)})`);
+						}
+					});
+				}
+			}
+		};
+	}
+};
+// vendor/src/rules/no-space-in-emphasis.js
+/**
+* @fileoverview Rule to prevent spaces around emphasis markers in Markdown.
+* @author Pixel998
+*/
+/**
+* @import { SourceRange } from "@eslint/core";
+* @import { Heading, Paragraph, TableCell, Text } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"spaceInEmphasis"} NoSpaceInEmphasisMessageIds
+* @typedef {[{ checkStrikethrough?: boolean }]} NoSpaceInEmphasisOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoSpaceInEmphasisOptions, MessageIds: NoSpaceInEmphasisMessageIds }>} NoSpaceInEmphasisRuleDefinition
+*/
+const whitespacePattern = /[ \t]/u;
+/**
+* Creates a marker pattern based on whether strikethrough should be included.
+* @param {boolean} checkStrikethrough Whether to include strikethrough markers.
+* @returns {RegExp} The marker pattern.
+*/
+function createMarkerPattern(checkStrikethrough) {
+	return checkStrikethrough ? /(?<=(?<!\\)(?:\\{2})*)(?:\*\*\*|\*\*|\*|___|__|_|~~|~)/gu : /(?<=(?<!\\)(?:\\{2})*)(?:\*\*\*|\*\*|\*|___|__|_)/gu;
+}
+var no_space_in_emphasis_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow spaces around emphasis markers",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-space-in-emphasis.md"
+		},
+		fixable: "whitespace",
+		messages: { spaceInEmphasis: "Unexpected space around emphasis marker." },
+		schema: [{
+			type: "object",
+			properties: { checkStrikethrough: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ checkStrikethrough: false }]
+	},
+	create(context) {
+		const { sourceCode } = context;
+		const [{ checkStrikethrough }] = context.options;
+		const markerPattern = createMarkerPattern(checkStrikethrough);
+		/** @type {string[]} */
+		let buffer;
+		/**
+		* Reports a surrounding-space violation if present.
+		* @param {number} checkIndex Character index to test for whitespace.
+		* @param {number} highlightStartIndex Start index for highlighting.
+		* @param {number} highlightEndIndex End index for highlighting.
+		* @returns {void}
+		*/
+		function reportWhitespace(checkIndex, highlightStartIndex, highlightEndIndex) {
+			if (whitespacePattern.test(sourceCode.text[checkIndex])) context.report({
+				loc: {
+					start: sourceCode.getLocFromIndex(highlightStartIndex),
+					end: sourceCode.getLocFromIndex(highlightEndIndex)
+				},
+				messageId: "spaceInEmphasis",
+				fix(fixer) {
+					return fixer.removeRange([checkIndex, checkIndex + 1]);
+				}
+			});
+		}
+		return {
+			"heading, paragraph, tableCell"(node) {
+				const [startOffset, endOffset] = sourceCode.getRange(node);
+				buffer = new Array(endOffset - startOffset).fill(" ");
+			},
+			":matches(heading, paragraph, tableCell) > text"(node) {
+				const [startOffset, endOffset] = sourceCode.getRange(node);
+				const parentNodeStartOffset = sourceCode.getParent(node).position.start.offset;
+				for (let i = startOffset; i < endOffset; i++) buffer[i - parentNodeStartOffset] = sourceCode.text[i];
+			},
+			":matches(heading, paragraph, tableCell):exit"(node) {
+				const maskedText = buffer.join("");
+				/** @type {Map<string, SourceRange[]>} */
+				const markerGroups = /* @__PURE__ */ new Map();
+				/** @type {RegExpExecArray | null} */
+				let match;
+				while ((match = markerPattern.exec(maskedText)) !== null) {
+					const marker = match[0];
+					const startOffset = match.index + node.position.start.offset;
+					const endOffset = startOffset + marker.length;
+					if (!markerGroups.has(marker)) markerGroups.set(marker, []);
+					markerGroups.get(marker).push([startOffset, endOffset]);
+				}
+				for (const group of markerGroups.values()) for (let i = 0; i < group.length - 1; i += 2) {
+					const startMarker = group[i];
+					reportWhitespace(startMarker[1], startMarker[0], startMarker[1] + 2);
+					const endMarker = group[i + 1];
+					reportWhitespace(endMarker[0] - 1, endMarker[0] - 2, endMarker[1]);
+				}
+			}
+		};
+	}
+};
+// vendor/src/rules/no-unused-definitions.js
+/**
+* @fileoverview Rule to prevent unused definitions in Markdown.
+* @author 루밀LuMir(lumirlumir)
+*/
+/**
+* @import { Definition, FootnoteDefinition } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"unusedDefinition" | "unusedFootnoteDefinition"} NoUnusedDefinitionsMessageIds
+* @typedef {[{ allowDefinitions?: string[], allowFootnoteDefinitions?: string[], checkFootnoteDefinitions?: boolean }]} NoUnusedDefinitionsOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: NoUnusedDefinitionsOptions, MessageIds: NoUnusedDefinitionsMessageIds }>} NoUnusedDefinitionsRuleDefinition
+*/
+var no_unused_definitions_default = {
+	meta: {
+		type: "problem",
+		languages: ["markdown/commonmark", "markdown/gfm"],
+		docs: {
+			recommended: true,
+			description: "Disallow unused definitions",
+			dialects: ["CommonMark", "GFM"],
+			url: "https://github.com/eslint/markdown/blob/main/docs/rules/no-unused-definitions.md"
+		},
+		messages: {
+			unusedDefinition: "Unexpected unused definition `{{ identifier }}` (label: `{{ label }}`) found.",
+			unusedFootnoteDefinition: "Unexpected unused footnote definition `{{ identifier }}` (label: `{{ label }}`) found."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				allowDefinitions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				allowFootnoteDefinitions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				checkFootnoteDefinitions: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		defaultOptions: [{
+			allowDefinitions: ["//"],
+			allowFootnoteDefinitions: [],
+			checkFootnoteDefinitions: true
+		}]
+	},
+	create(context) {
+		const allowDefinitions = new Set(context.options[0].allowDefinitions.map(normalizeIdentifier$1));
+		const allowFootnoteDefinitions = new Set(context.options[0].allowFootnoteDefinitions.map(normalizeIdentifier$1));
+		const [{ checkFootnoteDefinitions }] = context.options;
+		/** @type {Set<string>} Set to track used identifiers */
+		const usedIdentifiers = /* @__PURE__ */ new Set();
+		/** @type {Set<string>} Set to track used footnote identifiers */
+		const usedFootnoteIdentifiers = /* @__PURE__ */ new Set();
+		/** @type {Set<Definition>} */
+		const definitions = /* @__PURE__ */ new Set();
+		/** @type {Set<FootnoteDefinition>} */
+		const footnoteDefinitions = /* @__PURE__ */ new Set();
+		return {
+			imageReference(node) {
+				usedIdentifiers.add(node.identifier);
+			},
+			linkReference(node) {
+				usedIdentifiers.add(node.identifier);
+			},
+			footnoteReference(node) {
+				usedFootnoteIdentifiers.add(node.identifier);
+			},
+			definition(node) {
+				if (allowDefinitions.has(node.identifier)) return;
+				definitions.add(node);
+			},
+			footnoteDefinition(node) {
+				if (!checkFootnoteDefinitions || allowFootnoteDefinitions.has(node.identifier)) return;
+				footnoteDefinitions.add(node);
+			},
+			"root:exit"() {
+				for (const definition of definitions) if (!usedIdentifiers.has(definition.identifier)) context.report({
+					node: definition,
+					messageId: "unusedDefinition",
+					data: {
+						identifier: definition.identifier,
+						label: definition.label.trim()
+					}
+				});
+				for (const footnoteDefinition of footnoteDefinitions) if (!usedFootnoteIdentifiers.has(footnoteDefinition.identifier)) context.report({
+					node: footnoteDefinition,
+					messageId: "unusedFootnoteDefinition",
+					data: {
+						identifier: footnoteDefinition.identifier,
+						label: footnoteDefinition.label
+					}
+				});
+			}
+		};
+	}
+};
+// vendor/src/rules/require-alt-text.js
+/**
+* @fileoverview Rule to require alternative text for images in Markdown.
+* @author Pixel998
+*/
+/**
+* @import { Image, ImageReference } from "mdast";
+* @import { MarkdownRuleDefinition } from "../types.js";
+* @typedef {"altTextRequired"} RequireAltTextMessageIds
+* @typedef {[]} RequireAltTextOptions
+* @typedef {MarkdownRuleDefinition<{ RuleOptions: RequireAltTextOptions, MessageIds: RequireAltTextMessageIds }>} RequireAltTextRuleDefinition
+*/
+const imgTagPattern = /<img(?:\s(?:[^>"']|"[^"]*"|'[^']*')*)?\/?>/giu;
+const ariaHiddenTruePattern = /[\s"']aria-hidden\s*=\s*(?:"true"|'true'|true(?=\s|\/?>))/iu;
+/**
+* Creates a regex to match HTML attributes
+* @param {string} name The attribute name to match
+* @returns {RegExp} Regular expression for matching the attribute
+*/
+function getHtmlAttributeRe(name) {
+	return new RegExp(`\\s${name}(?:\\s*=\\s*['"]([^'"]*)['"])?`, "iu");
+}
+// vendor/src/build/rules.js
+var rules_default = {
+	"fenced-code-language": fenced_code_language_default,
+	"fenced-code-meta": fenced_code_meta_default,
+	"heading-increment": heading_increment_default,
+	"no-bare-urls": no_bare_urls_default,
+	"no-duplicate-definitions": no_duplicate_definitions_default,
+	"no-duplicate-headings": no_duplicate_headings_default,
+	"no-empty-definitions": no_empty_definitions_default,
+	"no-empty-images": no_empty_images_default,
+	"no-empty-links": no_empty_links_default,
+	"no-html": no_html_default,
+	"no-invalid-label-refs": no_invalid_label_refs_default,
+	"no-missing-atx-heading-space": no_missing_atx_heading_space_default,
+	"no-missing-label-refs": no_missing_label_refs_default,
+	"no-missing-link-fragments": no_missing_link_fragments_default,
+	"no-multiple-h1": no_multiple_h1_default,
+	"no-reference-like-urls": no_reference_like_urls_default,
+	"no-reversed-media-syntax": no_reversed_media_syntax_default,
+	"no-space-in-emphasis": no_space_in_emphasis_default,
+	"no-unused-definitions": no_unused_definitions_default,
+	"require-alt-text": {
+		meta: {
+			type: "problem",
+			languages: ["markdown/commonmark", "markdown/gfm"],
+			docs: {
+				recommended: true,
+				description: "Require alternative text for images",
+				dialects: ["CommonMark", "GFM"],
+				url: "https://github.com/eslint/markdown/blob/main/docs/rules/require-alt-text.md"
+			},
+			messages: { altTextRequired: "Alternative text for image is required." }
+		},
+		create(context) {
+			const { sourceCode } = context;
+			return {
+				"image, imageReference"(node) {
+					if (node.alt.trim().length === 0) context.report({
+						loc: node.position,
+						messageId: "altTextRequired"
+					});
+				},
+				html(node) {
+					const text = stripHtmlComments(sourceCode.getText(node));
+					/** @type {RegExpExecArray | null} */
+					let match;
+					while ((match = imgTagPattern.exec(text)) !== null) {
+						const imgTag = match[0];
+						if (ariaHiddenTruePattern.test(imgTag)) continue;
+						const altMatch = imgTag.match(getHtmlAttributeRe("alt"));
+						if (!altMatch || altMatch[1] && altMatch[1].trim().length === 0 && altMatch[1].length > 0) {
+							const startOffset = match.index + node.position.start.offset;
+							const endOffset = startOffset + imgTag.length;
+							context.report({
+								loc: {
+									start: sourceCode.getLocFromIndex(startOffset),
+									end: sourceCode.getLocFromIndex(endOffset)
+								},
+								messageId: "altTextRequired"
+							});
+						}
+					}
+				}
+			};
+		}
+	},
+	"table-column-count": {
+		meta: {
+			type: "problem",
+			languages: ["markdown/gfm"],
+			docs: {
+				description: "Disallow data rows in a GitHub Flavored Markdown table from having more cells than the header row",
+				dialects: ["GFM"],
+				url: "https://github.com/eslint/markdown/blob/main/docs/rules/table-column-count.md"
+			},
+			messages: {
+				extraCells: "Table column count mismatch (Expected: {{expectedCells}}, Actual: {{actualCells}}), extra data starting here will be ignored.",
+				missingCells: "Table column count mismatch (Expected: {{expectedCells}}, Actual: {{actualCells}}), row might be missing data."
+			},
+			schema: [{
+				type: "object",
+				properties: { checkMissingCells: { type: "boolean" } },
+				additionalProperties: false
+			}],
+			defaultOptions: [{ checkMissingCells: false }]
+		},
+		create(context) {
+			const [{ checkMissingCells }] = context.options;
+			return { table(node) {
+				if (node.children.length < 1) return;
+				const expectedCellsLength = node.children[0].children.length;
+				for (let i = 1; i < node.children.length; i++) {
+					const currentRow = node.children[i];
+					const actualCellsLength = currentRow.children.length;
+					const lastActualCellNode = currentRow.children[actualCellsLength - 1];
+					if (actualCellsLength > expectedCellsLength) {
+						const firstExtraCellNode = currentRow.children[expectedCellsLength];
+						context.report({
+							loc: {
+								start: firstExtraCellNode.position.start,
+								end: lastActualCellNode.position.end
+							},
+							messageId: "extraCells",
+							data: {
+								actualCells: actualCellsLength,
+								expectedCells: expectedCellsLength
+							}
+						});
+					} else if (checkMissingCells && actualCellsLength < expectedCellsLength) context.report({
+						loc: {
+							start: {
+								column: lastActualCellNode.position.end.column - 1,
+								line: lastActualCellNode.position.end.line
+							},
+							end: currentRow.position.end
+						},
+						messageId: "missingCells",
+						data: {
+							actualCells: actualCellsLength,
+							expectedCells: expectedCellsLength
+						}
+					});
+				}
+			} };
+		}
+	}
+};
+export { processor as a, MarkdownSourceCode as i, MarkdownLanguage as n, InlineConfigComment as r, rules_default as t };