@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/libs/mdast-util-gfm.mjs

@@ -0,0 +1,2393 @@
+import { t as ccount } from "./ccount.mjs";
+import { t as ok } from "./devlop.mjs";
+import { _ as unicodePunctuation, c as toString, l as classifyCharacter, u as normalizeIdentifier, v as unicodeWhitespace } from "./mdast-util-from-markdown.mjs";
+import { i as convert, n as EXIT, r as visitParents, t as findAndReplace } from "./mdast-util-find-and-replace.mjs";
+import { t as markdownTable } from "./markdown-table.mjs";
+import { t as longestStreak } from "./longest-streak.mjs";
+
+//#region ../../node_modules/.pnpm/mdast-util-gfm-autolink-literal@2.0.1/node_modules/mdast-util-gfm-autolink-literal/lib/index.js
+/**
+* @import {RegExpMatchObject, ReplaceFunction} from 'mdast-util-find-and-replace'
+* @import {CompileContext, Extension as FromMarkdownExtension, Handle as FromMarkdownHandle, Transform as FromMarkdownTransform} from 'mdast-util-from-markdown'
+* @import {ConstructName, Options as ToMarkdownExtension} from 'mdast-util-to-markdown'
+* @import {Link, PhrasingContent} from 'mdast'
+*/
+/** @type {ConstructName} */
+const inConstruct = "phrasing";
+/** @type {Array<ConstructName>} */
+const notInConstruct = [
+	"autolink",
+	"link",
+	"image",
+	"label"
+];
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM autolink
+* literals in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.
+*/
+function gfmAutolinkLiteralFromMarkdown() {
+	return {
+		transforms: [transformGfmAutolinkLiterals],
+		enter: {
+			literalAutolink: enterLiteralAutolink,
+			literalAutolinkEmail: enterLiteralAutolinkValue,
+			literalAutolinkHttp: enterLiteralAutolinkValue,
+			literalAutolinkWww: enterLiteralAutolinkValue
+		},
+		exit: {
+			literalAutolink: exitLiteralAutolink,
+			literalAutolinkEmail: exitLiteralAutolinkEmail,
+			literalAutolinkHttp: exitLiteralAutolinkHttp,
+			literalAutolinkWww: exitLiteralAutolinkWww
+		}
+	};
+}
+/**
+* Create an extension for `mdast-util-to-markdown` to enable GFM autolink
+* literals in markdown.
+*
+* @returns {ToMarkdownExtension}
+*   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.
+*/
+function gfmAutolinkLiteralToMarkdown() {
+	return { unsafe: [
+		{
+			character: "@",
+			before: "[+\\-.\\w]",
+			after: "[\\-.\\w]",
+			inConstruct,
+			notInConstruct
+		},
+		{
+			character: ".",
+			before: "[Ww]",
+			after: "[\\-.\\w]",
+			inConstruct,
+			notInConstruct
+		},
+		{
+			character: ":",
+			before: "[ps]",
+			after: "\\/",
+			inConstruct,
+			notInConstruct
+		}
+	] };
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterLiteralAutolink(token) {
+	this.enter({
+		type: "link",
+		title: null,
+		url: "",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterLiteralAutolinkValue(token) {
+	this.config.enter.autolinkProtocol.call(this, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolinkHttp(token) {
+	this.config.exit.autolinkProtocol.call(this, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolinkWww(token) {
+	this.config.exit.data.call(this, token);
+	const node = this.stack[this.stack.length - 1];
+	/* @__PURE__ */ ok(node.type === "link");
+	node.url = "http://" + this.sliceSerialize(token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolinkEmail(token) {
+	this.config.exit.autolinkEmail.call(this, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolink(token) {
+	this.exit(token);
+}
+/** @type {FromMarkdownTransform} */
+function transformGfmAutolinkLiterals(tree) {
+	findAndReplace(tree, [[/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, findUrl], [/(?<=^|\s|\p{P}|\p{S})([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/gu, findEmail]], { ignore: ["link", "linkReference"] });
+}
+/**
+* @type {ReplaceFunction}
+* @param {string} _
+* @param {string} protocol
+* @param {string} domain
+* @param {string} path
+* @param {RegExpMatchObject} match
+* @returns {Array<PhrasingContent> | Link | false}
+*/
+function findUrl(_, protocol, domain, path, match) {
+	let prefix = "";
+	if (!previous(match)) return false;
+	if (/^w/i.test(protocol)) {
+		domain = protocol + domain;
+		protocol = "";
+		prefix = "http://";
+	}
+	if (!isCorrectDomain(domain)) return false;
+	const parts = splitUrl(domain + path);
+	if (!parts[0]) return false;
+	/** @type {Link} */
+	const result = {
+		type: "link",
+		title: null,
+		url: prefix + protocol + parts[0],
+		children: [{
+			type: "text",
+			value: protocol + parts[0]
+		}]
+	};
+	if (parts[1]) return [result, {
+		type: "text",
+		value: parts[1]
+	}];
+	return result;
+}
+/**
+* @type {ReplaceFunction}
+* @param {string} _
+* @param {string} atext
+* @param {string} label
+* @param {RegExpMatchObject} match
+* @returns {Link | false}
+*/
+function findEmail(_, atext, label, match) {
+	if (!previous(match, true) || /[-\d_]$/.test(label)) return false;
+	return {
+		type: "link",
+		title: null,
+		url: "mailto:" + atext + "@" + label,
+		children: [{
+			type: "text",
+			value: atext + "@" + label
+		}]
+	};
+}
+/**
+* @param {string} domain
+* @returns {boolean}
+*/
+function isCorrectDomain(domain) {
+	const parts = domain.split(".");
+	if (parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\d]/.test(parts[parts.length - 2]))) return false;
+	return true;
+}
+/**
+* @param {string} url
+* @returns {[string, string | undefined]}
+*/
+function splitUrl(url) {
+	const trailExec = /[!"&'),.:;<>?\]}]+$/.exec(url);
+	if (!trailExec) return [url, void 0];
+	url = url.slice(0, trailExec.index);
+	let trail = trailExec[0];
+	let closingParenIndex = trail.indexOf(")");
+	const openingParens = ccount(url, "(");
+	let closingParens = ccount(url, ")");
+	while (closingParenIndex !== -1 && openingParens > closingParens) {
+		url += trail.slice(0, closingParenIndex + 1);
+		trail = trail.slice(closingParenIndex + 1);
+		closingParenIndex = trail.indexOf(")");
+		closingParens++;
+	}
+	return [url, trail];
+}
+/**
+* @param {RegExpMatchObject} match
+* @param {boolean | null | undefined} [email=false]
+* @returns {boolean}
+*/
+function previous(match, email) {
+	const code = match.input.charCodeAt(match.index - 1);
+	return (match.index === 0 || unicodeWhitespace(code) || unicodePunctuation(code)) && (!email || code !== 47);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-gfm-footnote@2.1.0/node_modules/mdast-util-gfm-footnote/lib/index.js
+/**
+* @import {
+*   CompileContext,
+*   Extension as FromMarkdownExtension,
+*   Handle as FromMarkdownHandle
+* } from 'mdast-util-from-markdown'
+* @import {ToMarkdownOptions} from 'mdast-util-gfm-footnote'
+* @import {
+*   Handle as ToMarkdownHandle,
+*   Map,
+*   Options as ToMarkdownExtension
+* } from 'mdast-util-to-markdown'
+* @import {FootnoteDefinition, FootnoteReference} from 'mdast'
+*/
+footnoteReference.peek = footnoteReferencePeek;
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteCallString() {
+	this.buffer();
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteCall(token) {
+	this.enter({
+		type: "footnoteReference",
+		identifier: "",
+		label: ""
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteDefinitionLabelString() {
+	this.buffer();
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteDefinition(token) {
+	this.enter({
+		type: "footnoteDefinition",
+		identifier: "",
+		label: "",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteCallString(token) {
+	const label = this.resume();
+	const node = this.stack[this.stack.length - 1];
+	/* @__PURE__ */ ok(node.type === "footnoteReference");
+	node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
+	node.label = label;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteCall(token) {
+	this.exit(token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteDefinitionLabelString(token) {
+	const label = this.resume();
+	const node = this.stack[this.stack.length - 1];
+	/* @__PURE__ */ ok(node.type === "footnoteDefinition");
+	node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
+	node.label = label;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteDefinition(token) {
+	this.exit(token);
+}
+/** @type {ToMarkdownHandle} */
+function footnoteReferencePeek() {
+	return "[";
+}
+/**
+* @type {ToMarkdownHandle}
+* @param {FootnoteReference} node
+*/
+function footnoteReference(node, _, state, info) {
+	const tracker = state.createTracker(info);
+	let value = tracker.move("[^");
+	const exit = state.enter("footnoteReference");
+	const subexit = state.enter("reference");
+	value += tracker.move(state.safe(state.associationId(node), {
+		after: "]",
+		before: value
+	}));
+	subexit();
+	exit();
+	value += tracker.move("]");
+	return value;
+}
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM footnotes
+* in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown`.
+*/
+function gfmFootnoteFromMarkdown() {
+	return {
+		enter: {
+			gfmFootnoteCallString: enterFootnoteCallString,
+			gfmFootnoteCall: enterFootnoteCall,
+			gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
+			gfmFootnoteDefinition: enterFootnoteDefinition
+		},
+		exit: {
+			gfmFootnoteCallString: exitFootnoteCallString,
+			gfmFootnoteCall: exitFootnoteCall,
+			gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
+			gfmFootnoteDefinition: exitFootnoteDefinition
+		}
+	};
+}
+/**
+* Create an extension for `mdast-util-to-markdown` to enable GFM footnotes
+* in markdown.
+*
+* @param {ToMarkdownOptions | null | undefined} [options]
+*   Configuration (optional).
+* @returns {ToMarkdownExtension}
+*   Extension for `mdast-util-to-markdown`.
+*/
+function gfmFootnoteToMarkdown(options) {
+	let firstLineBlank = false;
+	if (options && options.firstLineBlank) firstLineBlank = true;
+	return {
+		handlers: {
+			footnoteDefinition,
+			footnoteReference
+		},
+		unsafe: [{
+			character: "[",
+			inConstruct: [
+				"label",
+				"phrasing",
+				"reference"
+			]
+		}]
+	};
+	/**
+	* @type {ToMarkdownHandle}
+	* @param {FootnoteDefinition} node
+	*/
+	function footnoteDefinition(node, _, state, info) {
+		const tracker = state.createTracker(info);
+		let value = tracker.move("[^");
+		const exit = state.enter("footnoteDefinition");
+		const subexit = state.enter("label");
+		value += tracker.move(state.safe(state.associationId(node), {
+			before: value,
+			after: "]"
+		}));
+		subexit();
+		value += tracker.move("]:");
+		if (node.children && node.children.length > 0) {
+			tracker.shift(4);
+			value += tracker.move((firstLineBlank ? "\n" : " ") + state.indentLines(state.containerFlow(node, tracker.current()), firstLineBlank ? mapAll : mapExceptFirst));
+		}
+		exit();
+		return value;
+	}
+}
+/** @type {Map} */
+function mapExceptFirst(line, index, blank) {
+	return index === 0 ? line : mapAll(line, index, blank);
+}
+/** @type {Map} */
+function mapAll(line, index, blank) {
+	return (blank ? "" : "    ") + line;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-gfm-strikethrough@2.0.0/node_modules/mdast-util-gfm-strikethrough/lib/index.js
+/**
+* @typedef {import('mdast').Delete} Delete
+*
+* @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+*
+* @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName
+* @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+*/
+/**
+* List of constructs that occur in phrasing (paragraphs, headings), but cannot
+* contain strikethrough.
+* So they sort of cancel each other out.
+* Note: could use a better name.
+*
+* Note: keep in sync with: <https://github.com/syntax-tree/mdast-util-to-markdown/blob/8ce8dbf/lib/unsafe.js#L14>
+*
+* @type {Array<ConstructName>}
+*/
+const constructsWithoutStrikethrough = [
+	"autolink",
+	"destinationLiteral",
+	"destinationRaw",
+	"reference",
+	"titleQuote",
+	"titleApostrophe"
+];
+handleDelete.peek = peekDelete;
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM
+* strikethrough in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown` to enable GFM strikethrough.
+*/
+function gfmStrikethroughFromMarkdown() {
+	return {
+		canContainEols: ["delete"],
+		enter: { strikethrough: enterStrikethrough },
+		exit: { strikethrough: exitStrikethrough }
+	};
+}
+/**
+* Create an extension for `mdast-util-to-markdown` to enable GFM
+* strikethrough in markdown.
+*
+* @returns {ToMarkdownExtension}
+*   Extension for `mdast-util-to-markdown` to enable GFM strikethrough.
+*/
+function gfmStrikethroughToMarkdown() {
+	return {
+		unsafe: [{
+			character: "~",
+			inConstruct: "phrasing",
+			notInConstruct: constructsWithoutStrikethrough
+		}],
+		handlers: { delete: handleDelete }
+	};
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterStrikethrough(token) {
+	this.enter({
+		type: "delete",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitStrikethrough(token) {
+	this.exit(token);
+}
+/**
+* @type {ToMarkdownHandle}
+* @param {Delete} node
+*/
+function handleDelete(node, _, state, info) {
+	const tracker = state.createTracker(info);
+	const exit = state.enter("strikethrough");
+	let value = tracker.move("~~");
+	value += state.containerPhrasing(node, {
+		...tracker.current(),
+		before: value,
+		after: "~"
+	});
+	value += tracker.move("~~");
+	exit();
+	return value;
+}
+/** @type {ToMarkdownHandle} */
+function peekDelete() {
+	return "~";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/blockquote.js
+/**
+* @import {Blockquote, Parents} from 'mdast'
+* @import {Info, Map, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {Blockquote} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function blockquote(node, _, state, info) {
+	const exit = state.enter("blockquote");
+	const tracker = state.createTracker(info);
+	tracker.move("> ");
+	tracker.shift(2);
+	const value = state.indentLines(state.containerFlow(node, tracker.current()), map$1);
+	exit();
+	return value;
+}
+/** @type {Map} */
+function map$1(line, _, blank) {
+	return ">" + (blank ? "" : " ") + line;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
+/**
+* @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {Array<ConstructName>} stack
+* @param {Unsafe} pattern
+* @returns {boolean}
+*/
+function patternInScope(stack, pattern) {
+	return listInScope(stack, pattern.inConstruct, true) && !listInScope(stack, pattern.notInConstruct, false);
+}
+/**
+* @param {Array<ConstructName>} stack
+* @param {Unsafe['inConstruct']} list
+* @param {boolean} none
+* @returns {boolean}
+*/
+function listInScope(stack, list, none) {
+	if (typeof list === "string") list = [list];
+	if (!list || list.length === 0) return none;
+	let index = -1;
+	while (++index < list.length) if (stack.includes(list[index])) return true;
+	return false;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/break.js
+/**
+* @import {Break, Parents} from 'mdast'
+* @import {Info, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {Break} _
+* @param {Parents | undefined} _1
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function hardBreak(_, _1, state, info) {
+	let index = -1;
+	while (++index < state.unsafe.length) if (state.unsafe[index].character === "\n" && patternInScope(state.stack, state.unsafe[index])) return /[ \t]/.test(info.before) ? "" : " ";
+	return "\\\n";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Code} from 'mdast'
+*/
+/**
+* @param {Code} node
+* @param {State} state
+* @returns {boolean}
+*/
+function formatCodeAsIndented(node, state) {
+	return Boolean(state.options.fences === false && node.value && !node.lang && /[^ \r\n]/.test(node.value) && !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-fence.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['fence'], null | undefined>}
+*/
+function checkFence(state) {
+	const marker = state.options.fence || "`";
+	if (marker !== "`" && marker !== "~") throw new Error("Cannot serialize code with `" + marker + "` for `options.fence`, expected `` ` `` or `~`");
+	return marker;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/code.js
+/**
+* @import {Info, Map, State} from 'mdast-util-to-markdown'
+* @import {Code, Parents} from 'mdast'
+*/
+/**
+* @param {Code} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function code(node, _, state, info) {
+	const marker = checkFence(state);
+	const raw = node.value || "";
+	const suffix = marker === "`" ? "GraveAccent" : "Tilde";
+	if (formatCodeAsIndented(node, state)) {
+		const exit = state.enter("codeIndented");
+		const value = state.indentLines(raw, map);
+		exit();
+		return value;
+	}
+	const tracker = state.createTracker(info);
+	const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
+	const exit = state.enter("codeFenced");
+	let value = tracker.move(sequence);
+	if (node.lang) {
+		const subexit = state.enter(`codeFencedLang${suffix}`);
+		value += tracker.move(state.safe(node.lang, {
+			before: value,
+			after: " ",
+			encode: ["`"],
+			...tracker.current()
+		}));
+		subexit();
+	}
+	if (node.lang && node.meta) {
+		const subexit = state.enter(`codeFencedMeta${suffix}`);
+		value += tracker.move(" ");
+		value += tracker.move(state.safe(node.meta, {
+			before: value,
+			after: "\n",
+			encode: ["`"],
+			...tracker.current()
+		}));
+		subexit();
+	}
+	value += tracker.move("\n");
+	if (raw) value += tracker.move(raw + "\n");
+	value += tracker.move(sequence);
+	exit();
+	return value;
+}
+/** @type {Map} */
+function map(line, _, blank) {
+	return (blank ? "" : "    ") + line;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-quote.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['quote'], null | undefined>}
+*/
+function checkQuote(state) {
+	const marker = state.options.quote || "\"";
+	if (marker !== "\"" && marker !== "'") throw new Error("Cannot serialize title with `" + marker + "` for `options.quote`, expected `\"`, or `'`");
+	return marker;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/definition.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Definition, Parents} from 'mdast'
+*/
+/**
+* @param {Definition} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function definition(node, _, state, info) {
+	const quote = checkQuote(state);
+	const suffix = quote === "\"" ? "Quote" : "Apostrophe";
+	const exit = state.enter("definition");
+	let subexit = state.enter("label");
+	const tracker = state.createTracker(info);
+	let value = tracker.move("[");
+	value += tracker.move(state.safe(state.associationId(node), {
+		before: value,
+		after: "]",
+		...tracker.current()
+	}));
+	value += tracker.move("]: ");
+	subexit();
+	if (!node.url || /[\0- \u007F]/.test(node.url)) {
+		subexit = state.enter("destinationLiteral");
+		value += tracker.move("<");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: ">",
+			...tracker.current()
+		}));
+		value += tracker.move(">");
+	} else {
+		subexit = state.enter("destinationRaw");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: node.title ? " " : "\n",
+			...tracker.current()
+		}));
+	}
+	subexit();
+	if (node.title) {
+		subexit = state.enter(`title${suffix}`);
+		value += tracker.move(" " + quote);
+		value += tracker.move(state.safe(node.title, {
+			before: value,
+			after: quote,
+			...tracker.current()
+		}));
+		value += tracker.move(quote);
+		subexit();
+	}
+	exit();
+	return value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['emphasis'], null | undefined>}
+*/
+function checkEmphasis(state) {
+	const marker = state.options.emphasis || "*";
+	if (marker !== "*" && marker !== "_") throw new Error("Cannot serialize emphasis with `" + marker + "` for `options.emphasis`, expected `*`, or `_`");
+	return marker;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js
+/**
+* Encode a code point as a character reference.
+*
+* @param {number} code
+*   Code point to encode.
+* @returns {string}
+*   Encoded character reference.
+*/
+function encodeCharacterReference(code) {
+	return "&#x" + code.toString(16).toUpperCase() + ";";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/encode-info.js
+/**
+* @import {EncodeSides} from '../types.js'
+*/
+/**
+* Check whether to encode (as a character reference) the characters
+* surrounding an attention run.
+*
+* Which characters are around an attention run influence whether it works or
+* not.
+*
+* See <https://github.com/orgs/syntax-tree/discussions/60> for more info.
+* See this markdown in a particular renderer to see what works:
+*
+* ```markdown
+* |                         | A (letter inside) | B (punctuation inside) | C (whitespace inside) | D (nothing inside) |
+* | ----------------------- | ----------------- | ---------------------- | --------------------- | ------------------ |
+* | 1 (letter outside)      | x*y*z             | x*.*z                  | x* *z                 | x**z               |
+* | 2 (punctuation outside) | .*y*.             | .*.*.                  | .* *.                 | .**.               |
+* | 3 (whitespace outside)  | x *y* z           | x *.* z                | x * * z               | x ** z             |
+* | 4 (nothing outside)     | *x*               | *.*                    | * *                   | **                 |
+* ```
+*
+* @param {number} outside
+*   Code point on the outer side of the run.
+* @param {number} inside
+*   Code point on the inner side of the run.
+* @param {'*' | '_'} marker
+*   Marker of the run.
+*   Underscores are handled more strictly (they form less often) than
+*   asterisks.
+* @returns {EncodeSides}
+*   Whether to encode characters.
+*/
+function encodeInfo(outside, inside, marker) {
+	const outsideKind = classifyCharacter(outside);
+	const insideKind = classifyCharacter(inside);
+	if (outsideKind === void 0) return insideKind === void 0 ? marker === "_" ? {
+		inside: true,
+		outside: true
+	} : {
+		inside: false,
+		outside: false
+	} : insideKind === 1 ? {
+		inside: true,
+		outside: true
+	} : {
+		inside: false,
+		outside: true
+	};
+	if (outsideKind === 1) return insideKind === void 0 ? {
+		inside: false,
+		outside: false
+	} : insideKind === 1 ? {
+		inside: true,
+		outside: true
+	} : {
+		inside: false,
+		outside: false
+	};
+	return insideKind === void 0 ? {
+		inside: false,
+		outside: false
+	} : insideKind === 1 ? {
+		inside: true,
+		outside: false
+	} : {
+		inside: false,
+		outside: false
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Emphasis, Parents} from 'mdast'
+*/
+emphasis.peek = emphasisPeek;
+/**
+* @param {Emphasis} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function emphasis(node, _, state, info) {
+	const marker = checkEmphasis(state);
+	const exit = state.enter("emphasis");
+	const tracker = state.createTracker(info);
+	const before = tracker.move(marker);
+	let between = tracker.move(state.containerPhrasing(node, {
+		after: marker,
+		before,
+		...tracker.current()
+	}));
+	const betweenHead = between.charCodeAt(0);
+	const open = encodeInfo(info.before.charCodeAt(info.before.length - 1), betweenHead, marker);
+	if (open.inside) between = encodeCharacterReference(betweenHead) + between.slice(1);
+	const betweenTail = between.charCodeAt(between.length - 1);
+	const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
+	if (close.inside) between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+	const after = tracker.move(marker);
+	exit();
+	state.attentionEncodeSurroundingInfo = {
+		after: close.outside,
+		before: open.outside
+	};
+	return before + between + after;
+}
+/**
+* @param {Emphasis} _
+* @param {Parents | undefined} _1
+* @param {State} state
+* @returns {string}
+*/
+function emphasisPeek(_, _1, state) {
+	return state.options.emphasis || "*";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/unist-util-visit@5.0.0/node_modules/unist-util-visit/lib/index.js
+/**
+* @typedef {import('unist').Node} UnistNode
+* @typedef {import('unist').Parent} UnistParent
+* @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+*/
+/**
+* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+*   Test from `unist-util-is`.
+*
+*   Note: we have remove and add `undefined`, because otherwise when generating
+*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+*   which doesn’t work when publishing on npm.
+*/
+/**
+* @typedef {(
+*   Fn extends (value: any) => value is infer Thing
+*   ? Thing
+*   : Fallback
+* )} Predicate
+*   Get the value of a type guard `Fn`.
+* @template Fn
+*   Value; typically function that is a type guard (such as `(x): x is Y`).
+* @template Fallback
+*   Value to yield if `Fn` is not a type guard.
+*/
+/**
+* @typedef {(
+*   Check extends null | undefined // No test.
+*   ? Value
+*   : Value extends {type: Check} // String (type) test.
+*   ? Value
+*   : Value extends Check // Partial test.
+*   ? Value
+*   : Check extends Function // Function test.
+*   ? Predicate<Check, Value> extends Value
+*     ? Predicate<Check, Value>
+*     : never
+*   : never // Some other test?
+* )} MatchesOne
+*   Check whether a node matches a primitive check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test, but not arrays.
+*/
+/**
+* @typedef {(
+*   Check extends Array<any>
+*   ? MatchesOne<Value, Check[keyof Check]>
+*   : MatchesOne<Value, Check>
+* )} Matches
+*   Check whether a node matches a check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test.
+*/
+/**
+* @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
+*   Number; capped reasonably.
+*/
+/**
+* @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
+*   Increment a number in the type system.
+* @template {Uint} [I=0]
+*   Index.
+*/
+/**
+* @typedef {(
+*   Node extends UnistParent
+*   ? Node extends {children: Array<infer Children>}
+*     ? Child extends Children ? Node : never
+*     : never
+*   : never
+* )} InternalParent
+*   Collect nodes that can be parents of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent
+*   Collect nodes in `Tree` that can be parents of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Depth extends Max
+*   ? never
+*   :
+*     | InternalParent<Node, Child>
+*     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
+* )} InternalAncestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {(
+*   Tree extends UnistParent
+*     ? Depth extends Max
+*       ? Tree
+*       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
+*     : Tree
+* )} InclusiveDescendant
+*   Collect all (inclusive) descendants of `Tree`.
+*
+*   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
+*   > recurse without actually running into an infinite loop, which the
+*   > previous version did.
+*   >
+*   > Practically, a max of `2` is typically enough assuming a `Root` is
+*   > passed, but it doesn’t improve performance.
+*   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
+*   > Using up to `10` doesn’t hurt or help either.
+* @template {UnistNode} Tree
+*   Tree type.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @callback Visitor
+*   Handle a node (matching `test`, if given).
+*
+*   Visitors are free to transform `node`.
+*   They can also transform `parent`.
+*
+*   Replacing `node` itself, if `SKIP` is not returned, still causes its
+*   descendants to be walked (which is a bug).
+*
+*   When adding or removing previous siblings of `node` (or next siblings, in
+*   case of reverse), the `Visitor` should return a new `Index` to specify the
+*   sibling to traverse after `node` is traversed.
+*   Adding or removing next siblings of `node` (or previous siblings, in case
+*   of reverse) is handled as expected without needing to return a new `Index`.
+*
+*   Removing the children property of `parent` still results in them being
+*   traversed.
+* @param {Visited} node
+*   Found node.
+* @param {Visited extends UnistNode ? number | undefined : never} index
+*   Index of `node` in `parent`.
+* @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+*   Parent of `node`.
+* @returns {VisitorResult}
+*   What to do next.
+*
+*   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
+*   An `Action` is treated as a tuple of `[Action]`.
+*
+*   Passing a tuple back only makes sense if the `Action` is `SKIP`.
+*   When the `Action` is `EXIT`, that action can be returned.
+*   When the `Action` is `CONTINUE`, `Index` can be returned.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [Ancestor=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
+*   Build a typed `Visitor` function from a node and all possible parents.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Visited
+*   Node type.
+* @template {UnistParent} Ancestor
+*   Parent type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromMatch<
+*     Matches<Descendant, Check>,
+*     Extract<Descendant, UnistParent>
+*   >
+* )} BuildVisitorFromDescendants
+*   Build a typed `Visitor` function from a list of descendants and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Descendant
+*   Node type.
+* @template {Test} Check
+*   Test type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromDescendants<
+*     InclusiveDescendant<Tree>,
+*     Check
+*   >
+* )} BuildVisitor
+*   Build a typed `Visitor` function from a tree and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} [Tree=UnistNode]
+*   Node type.
+* @template {Test} [Check=Test]
+*   Test type.
+*/
+/**
+* Visit nodes.
+*
+* This algorithm performs *depth-first* *tree traversal* in *preorder*
+* (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+*
+* You can choose for which nodes `visitor` is called by passing a `test`.
+* For complex tests, you should test yourself in `visitor`, as it will be
+* faster and will have improved type information.
+*
+* Walking the tree is an intensive task.
+* Make use of the return values of the visitor when possible.
+* Instead of walking a tree multiple times, walk it once, use `unist-util-is`
+* to check if a node matches, and then perform different operations.
+*
+* You can change the tree.
+* See `Visitor` for more info.
+*
+* @overload
+* @param {Tree} tree
+* @param {Check} check
+* @param {BuildVisitor<Tree, Check>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @overload
+* @param {Tree} tree
+* @param {BuildVisitor<Tree>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @param {UnistNode} tree
+*   Tree to traverse.
+* @param {Visitor | Test} testOrVisitor
+*   `unist-util-is`-compatible test (optional, omit to pass a visitor).
+* @param {Visitor | boolean | null | undefined} [visitorOrReverse]
+*   Handle each node (when test is omitted, pass `reverse`).
+* @param {boolean | null | undefined} [maybeReverse=false]
+*   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+* @returns {undefined}
+*   Nothing.
+*
+* @template {UnistNode} Tree
+*   Node type.
+* @template {Test} Check
+*   `unist-util-is`-compatible test.
+*/
+function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+	/** @type {boolean | null | undefined} */
+	let reverse;
+	/** @type {Test} */
+	let test;
+	/** @type {Visitor} */
+	let visitor;
+	if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
+		test = void 0;
+		visitor = testOrVisitor;
+		reverse = visitorOrReverse;
+	} else {
+		test = testOrVisitor;
+		visitor = visitorOrReverse;
+		reverse = maybeReverse;
+	}
+	visitParents(tree, test, overload, reverse);
+	/**
+	* @param {UnistNode} node
+	* @param {Array<UnistParent>} parents
+	*/
+	function overload(node, parents) {
+		const parent = parents[parents.length - 1];
+		const index = parent ? parent.children.indexOf(node) : void 0;
+		return visitor(node, index, parent);
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Heading} from 'mdast'
+*/
+/**
+* @param {Heading} node
+* @param {State} state
+* @returns {boolean}
+*/
+function formatHeadingAsSetext(node, state) {
+	let literalWithBreak = false;
+	visit(node, function(node) {
+		if ("value" in node && /\r?\n|\r/.test(node.value) || node.type === "break") {
+			literalWithBreak = true;
+			return EXIT;
+		}
+	});
+	return Boolean((!node.depth || node.depth < 3) && toString(node) && (state.options.setext || literalWithBreak));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/heading.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Heading, Parents} from 'mdast'
+*/
+/**
+* @param {Heading} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function heading(node, _, state, info) {
+	const rank = Math.max(Math.min(6, node.depth || 1), 1);
+	const tracker = state.createTracker(info);
+	if (formatHeadingAsSetext(node, state)) {
+		const exit = state.enter("headingSetext");
+		const subexit = state.enter("phrasing");
+		const value = state.containerPhrasing(node, {
+			...tracker.current(),
+			before: "\n",
+			after: "\n"
+		});
+		subexit();
+		exit();
+		return value + "\n" + (rank === 1 ? "=" : "-").repeat(value.length - (Math.max(value.lastIndexOf("\r"), value.lastIndexOf("\n")) + 1));
+	}
+	const sequence = "#".repeat(rank);
+	const exit = state.enter("headingAtx");
+	const subexit = state.enter("phrasing");
+	tracker.move(sequence + " ");
+	let value = state.containerPhrasing(node, {
+		before: "# ",
+		after: "\n",
+		...tracker.current()
+	});
+	if (/^[\t ]/.test(value)) value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1);
+	value = value ? sequence + " " + value : sequence;
+	if (state.options.closeAtx) value += " " + sequence;
+	subexit();
+	exit();
+	return value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/html.js
+/**
+* @import {Html} from 'mdast'
+*/
+html.peek = htmlPeek;
+/**
+* @param {Html} node
+* @returns {string}
+*/
+function html(node) {
+	return node.value || "";
+}
+/**
+* @returns {string}
+*/
+function htmlPeek() {
+	return "<";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/image.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Image, Parents} from 'mdast'
+*/
+image.peek = imagePeek;
+/**
+* @param {Image} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function image(node, _, state, info) {
+	const quote = checkQuote(state);
+	const suffix = quote === "\"" ? "Quote" : "Apostrophe";
+	const exit = state.enter("image");
+	let subexit = state.enter("label");
+	const tracker = state.createTracker(info);
+	let value = tracker.move("![");
+	value += tracker.move(state.safe(node.alt, {
+		before: value,
+		after: "]",
+		...tracker.current()
+	}));
+	value += tracker.move("](");
+	subexit();
+	if (!node.url && node.title || /[\0- \u007F]/.test(node.url)) {
+		subexit = state.enter("destinationLiteral");
+		value += tracker.move("<");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: ">",
+			...tracker.current()
+		}));
+		value += tracker.move(">");
+	} else {
+		subexit = state.enter("destinationRaw");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: node.title ? " " : ")",
+			...tracker.current()
+		}));
+	}
+	subexit();
+	if (node.title) {
+		subexit = state.enter(`title${suffix}`);
+		value += tracker.move(" " + quote);
+		value += tracker.move(state.safe(node.title, {
+			before: value,
+			after: quote,
+			...tracker.current()
+		}));
+		value += tracker.move(quote);
+		subexit();
+	}
+	value += tracker.move(")");
+	exit();
+	return value;
+}
+/**
+* @returns {string}
+*/
+function imagePeek() {
+	return "!";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/image-reference.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {ImageReference, Parents} from 'mdast'
+*/
+imageReference.peek = imageReferencePeek;
+/**
+* @param {ImageReference} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function imageReference(node, _, state, info) {
+	const type = node.referenceType;
+	const exit = state.enter("imageReference");
+	let subexit = state.enter("label");
+	const tracker = state.createTracker(info);
+	let value = tracker.move("![");
+	const alt = state.safe(node.alt, {
+		before: value,
+		after: "]",
+		...tracker.current()
+	});
+	value += tracker.move(alt + "][");
+	subexit();
+	const stack = state.stack;
+	state.stack = [];
+	subexit = state.enter("reference");
+	const reference = state.safe(state.associationId(node), {
+		before: value,
+		after: "]",
+		...tracker.current()
+	});
+	subexit();
+	state.stack = stack;
+	exit();
+	if (type === "full" || !alt || alt !== reference) value += tracker.move(reference + "]");
+	else if (type === "shortcut") value = value.slice(0, -1);
+	else value += tracker.move("]");
+	return value;
+}
+/**
+* @returns {string}
+*/
+function imageReferencePeek() {
+	return "!";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {InlineCode, Parents} from 'mdast'
+*/
+inlineCode.peek = inlineCodePeek;
+/**
+* @param {InlineCode} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @returns {string}
+*/
+function inlineCode(node, _, state) {
+	let value = node.value || "";
+	let sequence = "`";
+	let index = -1;
+	while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) sequence += "`";
+	if (/[^ \r\n]/.test(value) && (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || /^`|`$/.test(value))) value = " " + value + " ";
+	while (++index < state.unsafe.length) {
+		const pattern = state.unsafe[index];
+		const expression = state.compilePattern(pattern);
+		/** @type {RegExpExecArray | null} */
+		let match;
+		if (!pattern.atBreak) continue;
+		while (match = expression.exec(value)) {
+			let position = match.index;
+			if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) position--;
+			value = value.slice(0, position) + " " + value.slice(match.index + 1);
+		}
+	}
+	return sequence + value + sequence;
+}
+/**
+* @returns {string}
+*/
+function inlineCodePeek() {
+	return "`";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Link} from 'mdast'
+*/
+/**
+* @param {Link} node
+* @param {State} state
+* @returns {boolean}
+*/
+function formatLinkAsAutolink(node, state) {
+	const raw = toString(node);
+	return Boolean(!state.options.resourceLink && node.url && !node.title && node.children && node.children.length === 1 && node.children[0].type === "text" && (raw === node.url || "mailto:" + raw === node.url) && /^[a-z][a-z+.-]+:/i.test(node.url) && !/[\0- <>\u007F]/.test(node.url));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/link.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Link, Parents} from 'mdast'
+* @import {Exit} from '../types.js'
+*/
+link.peek = linkPeek;
+/**
+* @param {Link} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function link(node, _, state, info) {
+	const quote = checkQuote(state);
+	const suffix = quote === "\"" ? "Quote" : "Apostrophe";
+	const tracker = state.createTracker(info);
+	/** @type {Exit} */
+	let exit;
+	/** @type {Exit} */
+	let subexit;
+	if (formatLinkAsAutolink(node, state)) {
+		const stack = state.stack;
+		state.stack = [];
+		exit = state.enter("autolink");
+		let value = tracker.move("<");
+		value += tracker.move(state.containerPhrasing(node, {
+			before: value,
+			after: ">",
+			...tracker.current()
+		}));
+		value += tracker.move(">");
+		exit();
+		state.stack = stack;
+		return value;
+	}
+	exit = state.enter("link");
+	subexit = state.enter("label");
+	let value = tracker.move("[");
+	value += tracker.move(state.containerPhrasing(node, {
+		before: value,
+		after: "](",
+		...tracker.current()
+	}));
+	value += tracker.move("](");
+	subexit();
+	if (!node.url && node.title || /[\0- \u007F]/.test(node.url)) {
+		subexit = state.enter("destinationLiteral");
+		value += tracker.move("<");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: ">",
+			...tracker.current()
+		}));
+		value += tracker.move(">");
+	} else {
+		subexit = state.enter("destinationRaw");
+		value += tracker.move(state.safe(node.url, {
+			before: value,
+			after: node.title ? " " : ")",
+			...tracker.current()
+		}));
+	}
+	subexit();
+	if (node.title) {
+		subexit = state.enter(`title${suffix}`);
+		value += tracker.move(" " + quote);
+		value += tracker.move(state.safe(node.title, {
+			before: value,
+			after: quote,
+			...tracker.current()
+		}));
+		value += tracker.move(quote);
+		subexit();
+	}
+	value += tracker.move(")");
+	exit();
+	return value;
+}
+/**
+* @param {Link} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @returns {string}
+*/
+function linkPeek(node, _, state) {
+	return formatLinkAsAutolink(node, state) ? "<" : "[";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/link-reference.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {LinkReference, Parents} from 'mdast'
+*/
+linkReference.peek = linkReferencePeek;
+/**
+* @param {LinkReference} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function linkReference(node, _, state, info) {
+	const type = node.referenceType;
+	const exit = state.enter("linkReference");
+	let subexit = state.enter("label");
+	const tracker = state.createTracker(info);
+	let value = tracker.move("[");
+	const text = state.containerPhrasing(node, {
+		before: value,
+		after: "]",
+		...tracker.current()
+	});
+	value += tracker.move(text + "][");
+	subexit();
+	const stack = state.stack;
+	state.stack = [];
+	subexit = state.enter("reference");
+	const reference = state.safe(state.associationId(node), {
+		before: value,
+		after: "]",
+		...tracker.current()
+	});
+	subexit();
+	state.stack = stack;
+	exit();
+	if (type === "full" || !text || text !== reference) value += tracker.move(reference + "]");
+	else if (type === "shortcut") value = value.slice(0, -1);
+	else value += tracker.move("]");
+	return value;
+}
+/**
+* @returns {string}
+*/
+function linkReferencePeek() {
+	return "[";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-bullet.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['bullet'], null | undefined>}
+*/
+function checkBullet(state) {
+	const marker = state.options.bullet || "*";
+	if (marker !== "*" && marker !== "+" && marker !== "-") throw new Error("Cannot serialize items with `" + marker + "` for `options.bullet`, expected `*`, `+`, or `-`");
+	return marker;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['bullet'], null | undefined>}
+*/
+function checkBulletOther(state) {
+	const bullet = checkBullet(state);
+	const bulletOther = state.options.bulletOther;
+	if (!bulletOther) return bullet === "*" ? "-" : "*";
+	if (bulletOther !== "*" && bulletOther !== "+" && bulletOther !== "-") throw new Error("Cannot serialize items with `" + bulletOther + "` for `options.bulletOther`, expected `*`, `+`, or `-`");
+	if (bulletOther === bullet) throw new Error("Expected `bullet` (`" + bullet + "`) and `bulletOther` (`" + bulletOther + "`) to be different");
+	return bulletOther;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['bulletOrdered'], null | undefined>}
+*/
+function checkBulletOrdered(state) {
+	const marker = state.options.bulletOrdered || ".";
+	if (marker !== "." && marker !== ")") throw new Error("Cannot serialize items with `" + marker + "` for `options.bulletOrdered`, expected `.` or `)`");
+	return marker;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-rule.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['rule'], null | undefined>}
+*/
+function checkRule(state) {
+	const marker = state.options.rule || "*";
+	if (marker !== "*" && marker !== "-" && marker !== "_") throw new Error("Cannot serialize rules with `" + marker + "` for `options.rule`, expected `*`, `-`, or `_`");
+	return marker;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {List, Parents} from 'mdast'
+*/
+/**
+* @param {List} node
+* @param {Parents | undefined} parent
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function list(node, parent, state, info) {
+	const exit = state.enter("list");
+	const bulletCurrent = state.bulletCurrent;
+	/** @type {string} */
+	let bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state);
+	/** @type {string} */
+	const bulletOther = node.ordered ? bullet === "." ? ")" : "." : checkBulletOther(state);
+	let useDifferentMarker = parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false;
+	if (!node.ordered) {
+		const firstListItem = node.children ? node.children[0] : void 0;
+		if ((bullet === "*" || bullet === "-") && firstListItem && (!firstListItem.children || !firstListItem.children[0]) && state.stack[state.stack.length - 1] === "list" && state.stack[state.stack.length - 2] === "listItem" && state.stack[state.stack.length - 3] === "list" && state.stack[state.stack.length - 4] === "listItem" && state.indexStack[state.indexStack.length - 1] === 0 && state.indexStack[state.indexStack.length - 2] === 0 && state.indexStack[state.indexStack.length - 3] === 0) useDifferentMarker = true;
+		if (checkRule(state) === bullet && firstListItem) {
+			let index = -1;
+			while (++index < node.children.length) {
+				const item = node.children[index];
+				if (item && item.type === "listItem" && item.children && item.children[0] && item.children[0].type === "thematicBreak") {
+					useDifferentMarker = true;
+					break;
+				}
+			}
+		}
+	}
+	if (useDifferentMarker) bullet = bulletOther;
+	state.bulletCurrent = bullet;
+	const value = state.containerFlow(node, info);
+	state.bulletLastUsed = bullet;
+	state.bulletCurrent = bulletCurrent;
+	exit();
+	return value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['listItemIndent'], null | undefined>}
+*/
+function checkListItemIndent(state) {
+	const style = state.options.listItemIndent || "one";
+	if (style !== "tab" && style !== "one" && style !== "mixed") throw new Error("Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`");
+	return style;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list-item.js
+/**
+* @import {Info, Map, State} from 'mdast-util-to-markdown'
+* @import {ListItem, Parents} from 'mdast'
+*/
+/**
+* @param {ListItem} node
+* @param {Parents | undefined} parent
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function listItem(node, parent, state, info) {
+	const listItemIndent = checkListItemIndent(state);
+	let bullet = state.bulletCurrent || checkBullet(state);
+	if (parent && parent.type === "list" && parent.ordered) bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + bullet;
+	let size = bullet.length + 1;
+	if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node.spread)) size = Math.ceil(size / 4) * 4;
+	const tracker = state.createTracker(info);
+	tracker.move(bullet + " ".repeat(size - bullet.length));
+	tracker.shift(size);
+	const exit = state.enter("listItem");
+	const value = state.indentLines(state.containerFlow(node, tracker.current()), map);
+	exit();
+	return value;
+	/** @type {Map} */
+	function map(line, index, blank) {
+		if (index) return (blank ? "" : " ".repeat(size)) + line;
+		return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/paragraph.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Paragraph, Parents} from 'mdast'
+*/
+/**
+* @param {Paragraph} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function paragraph(node, _, state, info) {
+	const exit = state.enter("paragraph");
+	const subexit = state.enter("phrasing");
+	const value = state.containerPhrasing(node, info);
+	subexit();
+	exit();
+	return value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-phrasing@4.1.0/node_modules/mdast-util-phrasing/lib/index.js
+/**
+* @typedef {import('mdast').Html} Html
+* @typedef {import('mdast').PhrasingContent} PhrasingContent
+*/
+/**
+* Check if the given value is *phrasing content*.
+*
+* > 👉 **Note**: Excludes `html`, which can be both phrasing or flow.
+*
+* @param node
+*   Thing to check, typically `Node`.
+* @returns
+*   Whether `value` is phrasing content.
+*/
+const phrasing = convert([
+	"break",
+	"delete",
+	"emphasis",
+	"footnote",
+	"footnoteReference",
+	"image",
+	"imageReference",
+	"inlineCode",
+	"inlineMath",
+	"link",
+	"linkReference",
+	"mdxJsxTextElement",
+	"mdxTextExpression",
+	"strong",
+	"text",
+	"textDirective"
+]);
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/root.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Root} from 'mdast'
+*/
+/**
+* @param {Root} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function root(node, _, state, info) {
+	return (node.children.some(function(d) {
+		return phrasing(d);
+	}) ? state.containerPhrasing : state.containerFlow).call(state, node, info);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-strong.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['strong'], null | undefined>}
+*/
+function checkStrong(state) {
+	const marker = state.options.strong || "*";
+	if (marker !== "*" && marker !== "_") throw new Error("Cannot serialize strong with `" + marker + "` for `options.strong`, expected `*`, or `_`");
+	return marker;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/strong.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Strong} from 'mdast'
+*/
+strong.peek = strongPeek;
+/**
+* @param {Strong} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function strong(node, _, state, info) {
+	const marker = checkStrong(state);
+	const exit = state.enter("strong");
+	const tracker = state.createTracker(info);
+	const before = tracker.move(marker + marker);
+	let between = tracker.move(state.containerPhrasing(node, {
+		after: marker,
+		before,
+		...tracker.current()
+	}));
+	const betweenHead = between.charCodeAt(0);
+	const open = encodeInfo(info.before.charCodeAt(info.before.length - 1), betweenHead, marker);
+	if (open.inside) between = encodeCharacterReference(betweenHead) + between.slice(1);
+	const betweenTail = between.charCodeAt(between.length - 1);
+	const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
+	if (close.inside) between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+	const after = tracker.move(marker + marker);
+	exit();
+	state.attentionEncodeSurroundingInfo = {
+		after: close.outside,
+		before: open.outside
+	};
+	return before + between + after;
+}
+/**
+* @param {Strong} _
+* @param {Parents | undefined} _1
+* @param {State} state
+* @returns {string}
+*/
+function strongPeek(_, _1, state) {
+	return state.options.strong || "*";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/text.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Text} from 'mdast'
+*/
+/**
+* @param {Text} node
+* @param {Parents | undefined} _
+* @param {State} state
+* @param {Info} info
+* @returns {string}
+*/
+function text(node, _, state, info) {
+	return state.safe(node.value, info);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js
+/**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
+* @param {State} state
+* @returns {Exclude<Options['ruleRepetition'], null | undefined>}
+*/
+function checkRuleRepetition(state) {
+	const repetition = state.options.ruleRepetition || 3;
+	if (repetition < 3) throw new Error("Cannot serialize rules with repetition `" + repetition + "` for `options.ruleRepetition`, expected `3` or more");
+	return repetition;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
+/**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Parents, ThematicBreak} from 'mdast'
+*/
+/**
+* @param {ThematicBreak} _
+* @param {Parents | undefined} _1
+* @param {State} state
+* @returns {string}
+*/
+function thematicBreak(_, _1, state) {
+	const value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
+	return state.options.ruleSpaces ? value.slice(0, -1) : value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/index.js
+/**
+* Default (CommonMark) handlers.
+*/
+const handle = {
+	blockquote,
+	break: hardBreak,
+	code,
+	definition,
+	emphasis,
+	hardBreak,
+	heading,
+	html,
+	image,
+	imageReference,
+	inlineCode,
+	link,
+	linkReference,
+	list,
+	listItem,
+	paragraph,
+	root,
+	strong,
+	text,
+	thematicBreak
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-gfm-table@2.0.0/node_modules/mdast-util-gfm-table/lib/index.js
+/**
+* @typedef {import('mdast').InlineCode} InlineCode
+* @typedef {import('mdast').Table} Table
+* @typedef {import('mdast').TableCell} TableCell
+* @typedef {import('mdast').TableRow} TableRow
+*
+* @typedef {import('markdown-table').Options} MarkdownTableOptions
+*
+* @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+*
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+* @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+* @typedef {import('mdast-util-to-markdown').State} State
+* @typedef {import('mdast-util-to-markdown').Info} Info
+*/
+/**
+* @typedef Options
+*   Configuration.
+* @property {boolean | null | undefined} [tableCellPadding=true]
+*   Whether to add a space of padding between delimiters and cells (default:
+*   `true`).
+* @property {boolean | null | undefined} [tablePipeAlign=true]
+*   Whether to align the delimiters (default: `true`).
+* @property {MarkdownTableOptions['stringLength'] | null | undefined} [stringLength]
+*   Function to detect the length of table cell content, used when aligning
+*   the delimiters between cells (optional).
+*/
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM tables in
+* markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown` to enable GFM tables.
+*/
+function gfmTableFromMarkdown() {
+	return {
+		enter: {
+			table: enterTable,
+			tableData: enterCell,
+			tableHeader: enterCell,
+			tableRow: enterRow
+		},
+		exit: {
+			codeText: exitCodeText,
+			table: exitTable,
+			tableData: exit,
+			tableHeader: exit,
+			tableRow: exit
+		}
+	};
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterTable(token) {
+	const align = token._align;
+	/* @__PURE__ */ ok(align, "expected `_align` on table");
+	this.enter({
+		type: "table",
+		align: align.map(function(d) {
+			return d === "none" ? null : d;
+		}),
+		children: []
+	}, token);
+	this.data.inTable = true;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitTable(token) {
+	this.exit(token);
+	this.data.inTable = void 0;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterRow(token) {
+	this.enter({
+		type: "tableRow",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exit(token) {
+	this.exit(token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterCell(token) {
+	this.enter({
+		type: "tableCell",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitCodeText(token) {
+	let value = this.resume();
+	if (this.data.inTable) value = value.replace(/\\([\\|])/g, replace);
+	const node = this.stack[this.stack.length - 1];
+	/* @__PURE__ */ ok(node.type === "inlineCode");
+	node.value = value;
+	this.exit(token);
+}
+/**
+* @param {string} $0
+* @param {string} $1
+* @returns {string}
+*/
+function replace($0, $1) {
+	return $1 === "|" ? $1 : $0;
+}
+/**
+* Create an extension for `mdast-util-to-markdown` to enable GFM tables in
+* markdown.
+*
+* @param {Options | null | undefined} [options]
+*   Configuration.
+* @returns {ToMarkdownExtension}
+*   Extension for `mdast-util-to-markdown` to enable GFM tables.
+*/
+function gfmTableToMarkdown(options) {
+	const settings = options || {};
+	const padding = settings.tableCellPadding;
+	const alignDelimiters = settings.tablePipeAlign;
+	const stringLength = settings.stringLength;
+	const around = padding ? " " : "|";
+	return {
+		unsafe: [
+			{
+				character: "\r",
+				inConstruct: "tableCell"
+			},
+			{
+				character: "\n",
+				inConstruct: "tableCell"
+			},
+			{
+				atBreak: true,
+				character: "|",
+				after: "[	 :-]"
+			},
+			{
+				character: "|",
+				inConstruct: "tableCell"
+			},
+			{
+				atBreak: true,
+				character: ":",
+				after: "-"
+			},
+			{
+				atBreak: true,
+				character: "-",
+				after: "[:|-]"
+			}
+		],
+		handlers: {
+			inlineCode: inlineCodeWithTable,
+			table: handleTable,
+			tableCell: handleTableCell,
+			tableRow: handleTableRow
+		}
+	};
+	/**
+	* @type {ToMarkdownHandle}
+	* @param {Table} node
+	*/
+	function handleTable(node, _, state, info) {
+		return serializeData(handleTableAsData(node, state, info), node.align);
+	}
+	/**
+	* This function isn’t really used normally, because we handle rows at the
+	* table level.
+	* But, if someone passes in a table row, this ensures we make somewhat sense.
+	*
+	* @type {ToMarkdownHandle}
+	* @param {TableRow} node
+	*/
+	function handleTableRow(node, _, state, info) {
+		const value = serializeData([handleTableRowAsData(node, state, info)]);
+		return value.slice(0, value.indexOf("\n"));
+	}
+	/**
+	* @type {ToMarkdownHandle}
+	* @param {TableCell} node
+	*/
+	function handleTableCell(node, _, state, info) {
+		const exit = state.enter("tableCell");
+		const subexit = state.enter("phrasing");
+		const value = state.containerPhrasing(node, {
+			...info,
+			before: around,
+			after: around
+		});
+		subexit();
+		exit();
+		return value;
+	}
+	/**
+	* @param {Array<Array<string>>} matrix
+	* @param {Array<string | null | undefined> | null | undefined} [align]
+	*/
+	function serializeData(matrix, align) {
+		return markdownTable(matrix, {
+			align,
+			alignDelimiters,
+			padding,
+			stringLength
+		});
+	}
+	/**
+	* @param {Table} node
+	* @param {State} state
+	* @param {Info} info
+	*/
+	function handleTableAsData(node, state, info) {
+		const children = node.children;
+		let index = -1;
+		/** @type {Array<Array<string>>} */
+		const result = [];
+		const subexit = state.enter("table");
+		while (++index < children.length) result[index] = handleTableRowAsData(children[index], state, info);
+		subexit();
+		return result;
+	}
+	/**
+	* @param {TableRow} node
+	* @param {State} state
+	* @param {Info} info
+	*/
+	function handleTableRowAsData(node, state, info) {
+		const children = node.children;
+		let index = -1;
+		/** @type {Array<string>} */
+		const result = [];
+		const subexit = state.enter("tableRow");
+		while (++index < children.length) result[index] = handleTableCell(children[index], node, state, info);
+		subexit();
+		return result;
+	}
+	/**
+	* @type {ToMarkdownHandle}
+	* @param {InlineCode} node
+	*/
+	function inlineCodeWithTable(node, parent, state) {
+		let value = handle.inlineCode(node, parent, state);
+		if (state.stack.includes("tableCell")) value = value.replace(/\|/g, "\\$&");
+		return value;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-gfm-task-list-item@2.0.0/node_modules/mdast-util-gfm-task-list-item/lib/index.js
+/**
+* @typedef {import('mdast').ListItem} ListItem
+* @typedef {import('mdast').Paragraph} Paragraph
+* @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+* @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+*/
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM task
+* list items in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown` to enable GFM task list items.
+*/
+function gfmTaskListItemFromMarkdown() {
+	return { exit: {
+		taskListCheckValueChecked: exitCheck,
+		taskListCheckValueUnchecked: exitCheck,
+		paragraph: exitParagraphWithTaskListItem
+	} };
+}
+/**
+* Create an extension for `mdast-util-to-markdown` to enable GFM task list
+* items in markdown.
+*
+* @returns {ToMarkdownExtension}
+*   Extension for `mdast-util-to-markdown` to enable GFM task list items.
+*/
+function gfmTaskListItemToMarkdown() {
+	return {
+		unsafe: [{
+			atBreak: true,
+			character: "-",
+			after: "[:|-]"
+		}],
+		handlers: { listItem: listItemWithTaskListItem }
+	};
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitCheck(token) {
+	const node = this.stack[this.stack.length - 2];
+	/* @__PURE__ */ ok(node.type === "listItem");
+	node.checked = token.type === "taskListCheckValueChecked";
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitParagraphWithTaskListItem(token) {
+	const parent = this.stack[this.stack.length - 2];
+	if (parent && parent.type === "listItem" && typeof parent.checked === "boolean") {
+		const node = this.stack[this.stack.length - 1];
+		/* @__PURE__ */ ok(node.type === "paragraph");
+		const head = node.children[0];
+		if (head && head.type === "text") {
+			const siblings = parent.children;
+			let index = -1;
+			/** @type {Paragraph | undefined} */
+			let firstParaghraph;
+			while (++index < siblings.length) {
+				const sibling = siblings[index];
+				if (sibling.type === "paragraph") {
+					firstParaghraph = sibling;
+					break;
+				}
+			}
+			if (firstParaghraph === node) {
+				head.value = head.value.slice(1);
+				if (head.value.length === 0) node.children.shift();
+				else if (node.position && head.position && typeof head.position.start.offset === "number") {
+					head.position.start.column++;
+					head.position.start.offset++;
+					node.position.start = Object.assign({}, head.position.start);
+				}
+			}
+		}
+	}
+	this.exit(token);
+}
+/**
+* @type {ToMarkdownHandle}
+* @param {ListItem} node
+*/
+function listItemWithTaskListItem(node, parent, state, info) {
+	const head = node.children[0];
+	const checkable = typeof node.checked === "boolean" && head && head.type === "paragraph";
+	const checkbox = "[" + (node.checked ? "x" : " ") + "] ";
+	const tracker = state.createTracker(info);
+	if (checkable) tracker.move(checkbox);
+	let value = handle.listItem(node, parent, state, {
+		...info,
+		...tracker.current()
+	});
+	if (checkable) value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check);
+	return value;
+	/**
+	* @param {string} $0
+	* @returns {string}
+	*/
+	function check($0) {
+		return $0 + checkbox;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mdast-util-gfm@3.1.0/node_modules/mdast-util-gfm/lib/index.js
+/**
+* @import {Extension as FromMarkdownExtension} from 'mdast-util-from-markdown'
+* @import {Options} from 'mdast-util-gfm'
+* @import {Options as ToMarkdownExtension} from 'mdast-util-to-markdown'
+*/
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM (autolink
+* literals, footnotes, strikethrough, tables, tasklists).
+*
+* @returns {Array<FromMarkdownExtension>}
+*   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,
+*   footnotes, strikethrough, tables, tasklists).
+*/
+function gfmFromMarkdown() {
+	return [
+		gfmAutolinkLiteralFromMarkdown(),
+		gfmFootnoteFromMarkdown(),
+		gfmStrikethroughFromMarkdown(),
+		gfmTableFromMarkdown(),
+		gfmTaskListItemFromMarkdown()
+	];
+}
+/**
+* Create an extension for `mdast-util-to-markdown` to enable GFM (autolink
+* literals, footnotes, strikethrough, tables, tasklists).
+*
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {ToMarkdownExtension}
+*   Extension for `mdast-util-to-markdown` to enable GFM (autolink literals,
+*   footnotes, strikethrough, tables, tasklists).
+*/
+function gfmToMarkdown(options) {
+	return { extensions: [
+		gfmAutolinkLiteralToMarkdown(),
+		gfmFootnoteToMarkdown(options),
+		gfmStrikethroughToMarkdown(),
+		gfmTableToMarkdown(options),
+		gfmTaskListItemToMarkdown()
+	] };
+}
+
+//#endregion
+export { gfmToMarkdown as n, visit as r, gfmFromMarkdown as t };