palettecn 0.1.0

package/dist/web/server/_libs/micromark-extension-gfm+[...].mjs

@@ -0,0 +1,2235 @@
+import { a as asciiAlphanumeric, d as markdownLineEnding, f as markdownLineEndingOrSpace, h as unicodeWhitespace, i as asciiAlpha, m as unicodePunctuation, n as factorySpace, p as markdownSpace, s as asciiControl } from "./@streamdown/math+[...].mjs";
+import { a as classifyCharacter, c as splice, n as blankLine, o as normalizeIdentifier, r as combineExtensions, s as resolveAll } from "./mdast-util-from-markdown+[...].mjs";
+//#region ../../node_modules/.pnpm/micromark-extension-gfm-autolink-literal@2.1.0/node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js
+/**
+* @import {Code, ConstructRecord, Event, Extension, Previous, State, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+var wwwPrefix = {
+	tokenize: tokenizeWwwPrefix,
+	partial: true
+};
+var domain = {
+	tokenize: tokenizeDomain,
+	partial: true
+};
+var path = {
+	tokenize: tokenizePath,
+	partial: true
+};
+var trail = {
+	tokenize: tokenizeTrail,
+	partial: true
+};
+var emailDomainDotTrail = {
+	tokenize: tokenizeEmailDomainDotTrail,
+	partial: true
+};
+var wwwAutolink = {
+	name: "wwwAutolink",
+	tokenize: tokenizeWwwAutolink,
+	previous: previousWww
+};
+var protocolAutolink = {
+	name: "protocolAutolink",
+	tokenize: tokenizeProtocolAutolink,
+	previous: previousProtocol
+};
+var emailAutolink = {
+	name: "emailAutolink",
+	tokenize: tokenizeEmailAutolink,
+	previous: previousEmail
+};
+/** @type {ConstructRecord} */
+var text = {};
+/**
+* Create an extension for `micromark` to support GitHub autolink literal
+* syntax.
+*
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `extensions` to enable GFM
+*   autolink literal syntax.
+*/
+function gfmAutolinkLiteral() {
+	return { text };
+}
+/** @type {Code} */
+var code = 48;
+while (code < 123) {
+	text[code] = emailAutolink;
+	code++;
+	if (code === 58) code = 65;
+	else if (code === 91) code = 97;
+}
+text[43] = emailAutolink;
+text[45] = emailAutolink;
+text[46] = emailAutolink;
+text[95] = emailAutolink;
+text[72] = [emailAutolink, protocolAutolink];
+text[104] = [emailAutolink, protocolAutolink];
+text[87] = [emailAutolink, wwwAutolink];
+text[119] = [emailAutolink, wwwAutolink];
+/**
+* Email autolink literal.
+*
+* ```markdown
+* > | a contact@example.org b
+*       ^^^^^^^^^^^^^^^^^^^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeEmailAutolink(effects, ok, nok) {
+	const self = this;
+	/** @type {boolean | undefined} */
+	let dot;
+	/** @type {boolean} */
+	let data;
+	return start;
+	/**
+	* Start of email autolink literal.
+	*
+	* ```markdown
+	* > | a contact@example.org b
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		if (!gfmAtext(code) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) return nok(code);
+		effects.enter("literalAutolink");
+		effects.enter("literalAutolinkEmail");
+		return atext(code);
+	}
+	/**
+	* In email atext.
+	*
+	* ```markdown
+	* > | a contact@example.org b
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function atext(code) {
+		if (gfmAtext(code)) {
+			effects.consume(code);
+			return atext;
+		}
+		if (code === 64) {
+			effects.consume(code);
+			return emailDomain;
+		}
+		return nok(code);
+	}
+	/**
+	* In email domain.
+	*
+	* The reference code is a bit overly complex as it handles the `@`, of which
+	* there may be just one.
+	* Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>
+	*
+	* ```markdown
+	* > | a contact@example.org b
+	*               ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function emailDomain(code) {
+		if (code === 46) return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code);
+		if (code === 45 || code === 95 || asciiAlphanumeric(code)) {
+			data = true;
+			effects.consume(code);
+			return emailDomain;
+		}
+		return emailDomainAfter(code);
+	}
+	/**
+	* In email domain, on dot that is not a trail.
+	*
+	* ```markdown
+	* > | a contact@example.org b
+	*                      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function emailDomainDot(code) {
+		effects.consume(code);
+		dot = true;
+		return emailDomain;
+	}
+	/**
+	* After email domain.
+	*
+	* ```markdown
+	* > | a contact@example.org b
+	*                          ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function emailDomainAfter(code) {
+		if (data && dot && asciiAlpha(self.previous)) {
+			effects.exit("literalAutolinkEmail");
+			effects.exit("literalAutolink");
+			return ok(code);
+		}
+		return nok(code);
+	}
+}
+/**
+* `www` autolink literal.
+*
+* ```markdown
+* > | a www.example.org b
+*       ^^^^^^^^^^^^^^^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeWwwAutolink(effects, ok, nok) {
+	const self = this;
+	return wwwStart;
+	/**
+	* Start of www autolink literal.
+	*
+	* ```markdown
+	* > | www.example.com/a?b#c
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function wwwStart(code) {
+		if (code !== 87 && code !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) return nok(code);
+		effects.enter("literalAutolink");
+		effects.enter("literalAutolinkWww");
+		return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code);
+	}
+	/**
+	* After a www autolink literal.
+	*
+	* ```markdown
+	* > | www.example.com/a?b#c
+	*                          ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function wwwAfter(code) {
+		effects.exit("literalAutolinkWww");
+		effects.exit("literalAutolink");
+		return ok(code);
+	}
+}
+/**
+* Protocol autolink literal.
+*
+* ```markdown
+* > | a https://example.org b
+*       ^^^^^^^^^^^^^^^^^^^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeProtocolAutolink(effects, ok, nok) {
+	const self = this;
+	let buffer = "";
+	let seen = false;
+	return protocolStart;
+	/**
+	* Start of protocol autolink literal.
+	*
+	* ```markdown
+	* > | https://example.com/a?b#c
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function protocolStart(code) {
+		if ((code === 72 || code === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {
+			effects.enter("literalAutolink");
+			effects.enter("literalAutolinkHttp");
+			buffer += String.fromCodePoint(code);
+			effects.consume(code);
+			return protocolPrefixInside;
+		}
+		return nok(code);
+	}
+	/**
+	* In protocol.
+	*
+	* ```markdown
+	* > | https://example.com/a?b#c
+	*     ^^^^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function protocolPrefixInside(code) {
+		if (asciiAlpha(code) && buffer.length < 5) {
+			buffer += String.fromCodePoint(code);
+			effects.consume(code);
+			return protocolPrefixInside;
+		}
+		if (code === 58) {
+			const protocol = buffer.toLowerCase();
+			if (protocol === "http" || protocol === "https") {
+				effects.consume(code);
+				return protocolSlashesInside;
+			}
+		}
+		return nok(code);
+	}
+	/**
+	* In slashes.
+	*
+	* ```markdown
+	* > | https://example.com/a?b#c
+	*           ^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function protocolSlashesInside(code) {
+		if (code === 47) {
+			effects.consume(code);
+			if (seen) return afterProtocol;
+			seen = true;
+			return protocolSlashesInside;
+		}
+		return nok(code);
+	}
+	/**
+	* After protocol, before domain.
+	*
+	* ```markdown
+	* > | https://example.com/a?b#c
+	*             ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function afterProtocol(code) {
+		return code === null || asciiControl(code) || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code);
+	}
+	/**
+	* After a protocol autolink literal.
+	*
+	* ```markdown
+	* > | https://example.com/a?b#c
+	*                              ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function protocolAfter(code) {
+		effects.exit("literalAutolinkHttp");
+		effects.exit("literalAutolink");
+		return ok(code);
+	}
+}
+/**
+* `www` prefix.
+*
+* ```markdown
+* > | a www.example.org b
+*       ^^^^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeWwwPrefix(effects, ok, nok) {
+	let size = 0;
+	return wwwPrefixInside;
+	/**
+	* In www prefix.
+	*
+	* ```markdown
+	* > | www.example.com
+	*     ^^^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function wwwPrefixInside(code) {
+		if ((code === 87 || code === 119) && size < 3) {
+			size++;
+			effects.consume(code);
+			return wwwPrefixInside;
+		}
+		if (code === 46 && size === 3) {
+			effects.consume(code);
+			return wwwPrefixAfter;
+		}
+		return nok(code);
+	}
+	/**
+	* After www prefix.
+	*
+	* ```markdown
+	* > | www.example.com
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function wwwPrefixAfter(code) {
+		return code === null ? nok(code) : ok(code);
+	}
+}
+/**
+* Domain.
+*
+* ```markdown
+* > | a https://example.org b
+*               ^^^^^^^^^^^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeDomain(effects, ok, nok) {
+	/** @type {boolean | undefined} */
+	let underscoreInLastSegment;
+	/** @type {boolean | undefined} */
+	let underscoreInLastLastSegment;
+	/** @type {boolean | undefined} */
+	let seen;
+	return domainInside;
+	/**
+	* In domain.
+	*
+	* ```markdown
+	* > | https://example.com/a
+	*             ^^^^^^^^^^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function domainInside(code) {
+		if (code === 46 || code === 95) return effects.check(trail, domainAfter, domainAtPunctuation)(code);
+		if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || code !== 45 && unicodePunctuation(code)) return domainAfter(code);
+		seen = true;
+		effects.consume(code);
+		return domainInside;
+	}
+	/**
+	* In domain, at potential trailing punctuation, that was not trailing.
+	*
+	* ```markdown
+	* > | https://example.com
+	*                    ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function domainAtPunctuation(code) {
+		if (code === 95) underscoreInLastSegment = true;
+		else {
+			underscoreInLastLastSegment = underscoreInLastSegment;
+			underscoreInLastSegment = void 0;
+		}
+		effects.consume(code);
+		return domainInside;
+	}
+	/**
+	* After domain.
+	*
+	* ```markdown
+	* > | https://example.com/a
+	*                        ^
+	* ```
+	*
+	* @type {State} */
+	function domainAfter(code) {
+		if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) return nok(code);
+		return ok(code);
+	}
+}
+/**
+* Path.
+*
+* ```markdown
+* > | a https://example.org/stuff b
+*                          ^^^^^^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizePath(effects, ok) {
+	let sizeOpen = 0;
+	let sizeClose = 0;
+	return pathInside;
+	/**
+	* In path.
+	*
+	* ```markdown
+	* > | https://example.com/a
+	*                        ^^
+	* ```
+	*
+	* @type {State}
+	*/
+	function pathInside(code) {
+		if (code === 40) {
+			sizeOpen++;
+			effects.consume(code);
+			return pathInside;
+		}
+		if (code === 41 && sizeClose < sizeOpen) return pathAtPunctuation(code);
+		if (code === 33 || code === 34 || code === 38 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 60 || code === 63 || code === 93 || code === 95 || code === 126) return effects.check(trail, ok, pathAtPunctuation)(code);
+		if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) return ok(code);
+		effects.consume(code);
+		return pathInside;
+	}
+	/**
+	* In path, at potential trailing punctuation, that was not trailing.
+	*
+	* ```markdown
+	* > | https://example.com/a"b
+	*                          ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function pathAtPunctuation(code) {
+		if (code === 41) sizeClose++;
+		effects.consume(code);
+		return pathInside;
+	}
+}
+/**
+* Trail.
+*
+* This calls `ok` if this *is* the trail, followed by an end, which means
+* the entire trail is not part of the link.
+* It calls `nok` if this *is* part of the link.
+*
+* ```markdown
+* > | https://example.com").
+*                        ^^^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeTrail(effects, ok, nok) {
+	return trail;
+	/**
+	* In trail of domain or path.
+	*
+	* ```markdown
+	* > | https://example.com").
+	*                        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function trail(code) {
+		if (code === 33 || code === 34 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 63 || code === 95 || code === 126) {
+			effects.consume(code);
+			return trail;
+		}
+		if (code === 38) {
+			effects.consume(code);
+			return trailCharacterReferenceStart;
+		}
+		if (code === 93) {
+			effects.consume(code);
+			return trailBracketAfter;
+		}
+		if (code === 60 || code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) return ok(code);
+		return nok(code);
+	}
+	/**
+	* In trail, after `]`.
+	*
+	* > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.
+	* > See end of <https://github.com/github/cmark-gfm/issues/278> for more.
+	*
+	* ```markdown
+	* > | https://example.com](
+	*                         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function trailBracketAfter(code) {
+		if (code === null || code === 40 || code === 91 || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) return ok(code);
+		return trail(code);
+	}
+	/**
+	* In character-reference like trail, after `&`.
+	*
+	* ```markdown
+	* > | https://example.com&amp;).
+	*                         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function trailCharacterReferenceStart(code) {
+		return asciiAlpha(code) ? trailCharacterReferenceInside(code) : nok(code);
+	}
+	/**
+	* In character-reference like trail.
+	*
+	* ```markdown
+	* > | https://example.com&amp;).
+	*                         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function trailCharacterReferenceInside(code) {
+		if (code === 59) {
+			effects.consume(code);
+			return trail;
+		}
+		if (asciiAlpha(code)) {
+			effects.consume(code);
+			return trailCharacterReferenceInside;
+		}
+		return nok(code);
+	}
+}
+/**
+* Dot in email domain trail.
+*
+* This calls `ok` if this *is* the trail, followed by an end, which means
+* the trail is not part of the link.
+* It calls `nok` if this *is* part of the link.
+*
+* ```markdown
+* > | contact@example.org.
+*                        ^
+* ```
+*
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeEmailDomainDotTrail(effects, ok, nok) {
+	return start;
+	/**
+	* Dot.
+	*
+	* ```markdown
+	* > | contact@example.org.
+	*                    ^   ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.consume(code);
+		return after;
+	}
+	/**
+	* After dot.
+	*
+	* ```markdown
+	* > | contact@example.org.
+	*                     ^   ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		return asciiAlphanumeric(code) ? nok(code) : ok(code);
+	}
+}
+/**
+* See:
+* <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.
+*
+* @type {Previous}
+*/
+function previousWww(code) {
+	return code === null || code === 40 || code === 42 || code === 95 || code === 91 || code === 93 || code === 126 || markdownLineEndingOrSpace(code);
+}
+/**
+* See:
+* <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.
+*
+* @type {Previous}
+*/
+function previousProtocol(code) {
+	return !asciiAlpha(code);
+}
+/**
+* @this {TokenizeContext}
+* @type {Previous}
+*/
+function previousEmail(code) {
+	return !(code === 47 || gfmAtext(code));
+}
+/**
+* @param {Code} code
+* @returns {boolean}
+*/
+function gfmAtext(code) {
+	return code === 43 || code === 45 || code === 46 || code === 95 || asciiAlphanumeric(code);
+}
+/**
+* @param {Array<Event>} events
+* @returns {boolean}
+*/
+function previousUnbalanced(events) {
+	let index = events.length;
+	let result = false;
+	while (index--) {
+		const token = events[index][1];
+		if ((token.type === "labelLink" || token.type === "labelImage") && !token._balanced) {
+			result = true;
+			break;
+		}
+		if (token._gfmAutolinkLiteralWalkedInto) {
+			result = false;
+			break;
+		}
+	}
+	if (events.length > 0 && !result) events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/micromark-extension-gfm-footnote@2.1.0/node_modules/micromark-extension-gfm-footnote/lib/syntax.js
+/**
+* @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+var indent = {
+	tokenize: tokenizeIndent,
+	partial: true
+};
+/**
+* Create an extension for `micromark` to enable GFM footnote syntax.
+*
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `extensions` to
+*   enable GFM footnote syntax.
+*/
+function gfmFootnote() {
+	/** @type {Extension} */
+	return {
+		document: { [91]: {
+			name: "gfmFootnoteDefinition",
+			tokenize: tokenizeDefinitionStart,
+			continuation: { tokenize: tokenizeDefinitionContinuation },
+			exit: gfmFootnoteDefinitionEnd
+		} },
+		text: {
+			[91]: {
+				name: "gfmFootnoteCall",
+				tokenize: tokenizeGfmFootnoteCall
+			},
+			[93]: {
+				name: "gfmPotentialFootnoteCall",
+				add: "after",
+				tokenize: tokenizePotentialGfmFootnoteCall,
+				resolveTo: resolveToPotentialGfmFootnoteCall
+			}
+		}
+	};
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizePotentialGfmFootnoteCall(effects, ok, nok) {
+	const self = this;
+	let index = self.events.length;
+	const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+	/** @type {Token} */
+	let labelStart;
+	while (index--) {
+		const token = self.events[index][1];
+		if (token.type === "labelImage") {
+			labelStart = token;
+			break;
+		}
+		if (token.type === "gfmFootnoteCall" || token.type === "labelLink" || token.type === "label" || token.type === "image" || token.type === "link") break;
+	}
+	return start;
+	/**
+	* @type {State}
+	*/
+	function start(code) {
+		if (!labelStart || !labelStart._balanced) return nok(code);
+		const id = normalizeIdentifier(self.sliceSerialize({
+			start: labelStart.end,
+			end: self.now()
+		}));
+		if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) return nok(code);
+		effects.enter("gfmFootnoteCallLabelMarker");
+		effects.consume(code);
+		effects.exit("gfmFootnoteCallLabelMarker");
+		return ok(code);
+	}
+}
+/** @type {Resolver} */
+function resolveToPotentialGfmFootnoteCall(events, context) {
+	let index = events.length;
+	while (index--) if (events[index][1].type === "labelImage" && events[index][0] === "enter") {
+		events[index][1];
+		break;
+	}
+	events[index + 1][1].type = "data";
+	events[index + 3][1].type = "gfmFootnoteCallLabelMarker";
+	/** @type {Token} */
+	const call = {
+		type: "gfmFootnoteCall",
+		start: Object.assign({}, events[index + 3][1].start),
+		end: Object.assign({}, events[events.length - 1][1].end)
+	};
+	/** @type {Token} */
+	const marker = {
+		type: "gfmFootnoteCallMarker",
+		start: Object.assign({}, events[index + 3][1].end),
+		end: Object.assign({}, events[index + 3][1].end)
+	};
+	marker.end.column++;
+	marker.end.offset++;
+	marker.end._bufferIndex++;
+	/** @type {Token} */
+	const string = {
+		type: "gfmFootnoteCallString",
+		start: Object.assign({}, marker.end),
+		end: Object.assign({}, events[events.length - 1][1].start)
+	};
+	/** @type {Token} */
+	const chunk = {
+		type: "chunkString",
+		contentType: "string",
+		start: Object.assign({}, string.start),
+		end: Object.assign({}, string.end)
+	};
+	/** @type {Array<Event>} */
+	const replacement = [
+		events[index + 1],
+		events[index + 2],
+		[
+			"enter",
+			call,
+			context
+		],
+		events[index + 3],
+		events[index + 4],
+		[
+			"enter",
+			marker,
+			context
+		],
+		[
+			"exit",
+			marker,
+			context
+		],
+		[
+			"enter",
+			string,
+			context
+		],
+		[
+			"enter",
+			chunk,
+			context
+		],
+		[
+			"exit",
+			chunk,
+			context
+		],
+		[
+			"exit",
+			string,
+			context
+		],
+		events[events.length - 2],
+		events[events.length - 1],
+		[
+			"exit",
+			call,
+			context
+		]
+	];
+	events.splice(index, events.length - index + 1, ...replacement);
+	return events;
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeGfmFootnoteCall(effects, ok, nok) {
+	const self = this;
+	const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+	let size = 0;
+	/** @type {boolean} */
+	let data;
+	return start;
+	/**
+	* Start of footnote label.
+	*
+	* ```markdown
+	* > | a [^b] c
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("gfmFootnoteCall");
+		effects.enter("gfmFootnoteCallLabelMarker");
+		effects.consume(code);
+		effects.exit("gfmFootnoteCallLabelMarker");
+		return callStart;
+	}
+	/**
+	* After `[`, at `^`.
+	*
+	* ```markdown
+	* > | a [^b] c
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function callStart(code) {
+		if (code !== 94) return nok(code);
+		effects.enter("gfmFootnoteCallMarker");
+		effects.consume(code);
+		effects.exit("gfmFootnoteCallMarker");
+		effects.enter("gfmFootnoteCallString");
+		effects.enter("chunkString").contentType = "string";
+		return callData;
+	}
+	/**
+	* In label.
+	*
+	* ```markdown
+	* > | a [^b] c
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function callData(code) {
+		if (size > 999 || code === 93 && !data || code === null || code === 91 || markdownLineEndingOrSpace(code)) return nok(code);
+		if (code === 93) {
+			effects.exit("chunkString");
+			const token = effects.exit("gfmFootnoteCallString");
+			if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) return nok(code);
+			effects.enter("gfmFootnoteCallLabelMarker");
+			effects.consume(code);
+			effects.exit("gfmFootnoteCallLabelMarker");
+			effects.exit("gfmFootnoteCall");
+			return ok;
+		}
+		if (!markdownLineEndingOrSpace(code)) data = true;
+		size++;
+		effects.consume(code);
+		return code === 92 ? callEscape : callData;
+	}
+	/**
+	* On character after escape.
+	*
+	* ```markdown
+	* > | a [^b\c] d
+	*           ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function callEscape(code) {
+		if (code === 91 || code === 92 || code === 93) {
+			effects.consume(code);
+			size++;
+			return callData;
+		}
+		return callData(code);
+	}
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeDefinitionStart(effects, ok, nok) {
+	const self = this;
+	const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
+	/** @type {string} */
+	let identifier;
+	let size = 0;
+	/** @type {boolean | undefined} */
+	let data;
+	return start;
+	/**
+	* Start of GFM footnote definition.
+	*
+	* ```markdown
+	* > | [^a]: b
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("gfmFootnoteDefinition")._container = true;
+		effects.enter("gfmFootnoteDefinitionLabel");
+		effects.enter("gfmFootnoteDefinitionLabelMarker");
+		effects.consume(code);
+		effects.exit("gfmFootnoteDefinitionLabelMarker");
+		return labelAtMarker;
+	}
+	/**
+	* In label, at caret.
+	*
+	* ```markdown
+	* > | [^a]: b
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function labelAtMarker(code) {
+		if (code === 94) {
+			effects.enter("gfmFootnoteDefinitionMarker");
+			effects.consume(code);
+			effects.exit("gfmFootnoteDefinitionMarker");
+			effects.enter("gfmFootnoteDefinitionLabelString");
+			effects.enter("chunkString").contentType = "string";
+			return labelInside;
+		}
+		return nok(code);
+	}
+	/**
+	* In label.
+	*
+	* > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote
+	* > definition labels.
+	*
+	* ```markdown
+	* > | [^a]: b
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function labelInside(code) {
+		if (size > 999 || code === 93 && !data || code === null || code === 91 || markdownLineEndingOrSpace(code)) return nok(code);
+		if (code === 93) {
+			effects.exit("chunkString");
+			const token = effects.exit("gfmFootnoteDefinitionLabelString");
+			identifier = normalizeIdentifier(self.sliceSerialize(token));
+			effects.enter("gfmFootnoteDefinitionLabelMarker");
+			effects.consume(code);
+			effects.exit("gfmFootnoteDefinitionLabelMarker");
+			effects.exit("gfmFootnoteDefinitionLabel");
+			return labelAfter;
+		}
+		if (!markdownLineEndingOrSpace(code)) data = true;
+		size++;
+		effects.consume(code);
+		return code === 92 ? labelEscape : labelInside;
+	}
+	/**
+	* After `\`, at a special character.
+	*
+	* > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:
+	* > <https://github.com/github/cmark-gfm/issues/240>
+	*
+	* ```markdown
+	* > | [^a\*b]: c
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function labelEscape(code) {
+		if (code === 91 || code === 92 || code === 93) {
+			effects.consume(code);
+			size++;
+			return labelInside;
+		}
+		return labelInside(code);
+	}
+	/**
+	* After definition label.
+	*
+	* ```markdown
+	* > | [^a]: b
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function labelAfter(code) {
+		if (code === 58) {
+			effects.enter("definitionMarker");
+			effects.consume(code);
+			effects.exit("definitionMarker");
+			if (!defined.includes(identifier)) defined.push(identifier);
+			return factorySpace(effects, whitespaceAfter, "gfmFootnoteDefinitionWhitespace");
+		}
+		return nok(code);
+	}
+	/**
+	* After definition prefix.
+	*
+	* ```markdown
+	* > | [^a]: b
+	*           ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function whitespaceAfter(code) {
+		return ok(code);
+	}
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeDefinitionContinuation(effects, ok, nok) {
+	return effects.check(blankLine, ok, effects.attempt(indent, ok, nok));
+}
+/** @type {Exiter} */
+function gfmFootnoteDefinitionEnd(effects) {
+	effects.exit("gfmFootnoteDefinition");
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeIndent(effects, ok, nok) {
+	const self = this;
+	return factorySpace(effects, afterPrefix, "gfmFootnoteDefinitionIndent", 5);
+	/**
+	* @type {State}
+	*/
+	function afterPrefix(code) {
+		const tail = self.events[self.events.length - 1];
+		return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/micromark-extension-gfm-strikethrough@2.1.0/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js
+/**
+* @import {Options} from 'micromark-extension-gfm-strikethrough'
+* @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+/**
+* Create an extension for `micromark` to enable GFM strikethrough syntax.
+*
+* @param {Options | null | undefined} [options={}]
+*   Configuration.
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `extensions`, to
+*   enable GFM strikethrough syntax.
+*/
+function gfmStrikethrough(options) {
+	let single = (options || {}).singleTilde;
+	const tokenizer = {
+		name: "strikethrough",
+		tokenize: tokenizeStrikethrough,
+		resolveAll: resolveAllStrikethrough
+	};
+	if (single === null || single === void 0) single = true;
+	return {
+		text: { [126]: tokenizer },
+		insideSpan: { null: [tokenizer] },
+		attentionMarkers: { null: [126] }
+	};
+	/**
+	* Take events and resolve strikethrough.
+	*
+	* @type {Resolver}
+	*/
+	function resolveAllStrikethrough(events, context) {
+		let index = -1;
+		while (++index < events.length) if (events[index][0] === "enter" && events[index][1].type === "strikethroughSequenceTemporary" && events[index][1]._close) {
+			let open = index;
+			while (open--) if (events[open][0] === "exit" && events[open][1].type === "strikethroughSequenceTemporary" && events[open][1]._open && events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {
+				events[index][1].type = "strikethroughSequence";
+				events[open][1].type = "strikethroughSequence";
+				/** @type {Token} */
+				const strikethrough = {
+					type: "strikethrough",
+					start: Object.assign({}, events[open][1].start),
+					end: Object.assign({}, events[index][1].end)
+				};
+				/** @type {Token} */
+				const text = {
+					type: "strikethroughText",
+					start: Object.assign({}, events[open][1].end),
+					end: Object.assign({}, events[index][1].start)
+				};
+				/** @type {Array<Event>} */
+				const nextEvents = [
+					[
+						"enter",
+						strikethrough,
+						context
+					],
+					[
+						"enter",
+						events[open][1],
+						context
+					],
+					[
+						"exit",
+						events[open][1],
+						context
+					],
+					[
+						"enter",
+						text,
+						context
+					]
+				];
+				const insideSpan = context.parser.constructs.insideSpan.null;
+				if (insideSpan) splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));
+				splice(nextEvents, nextEvents.length, 0, [
+					[
+						"exit",
+						text,
+						context
+					],
+					[
+						"enter",
+						events[index][1],
+						context
+					],
+					[
+						"exit",
+						events[index][1],
+						context
+					],
+					[
+						"exit",
+						strikethrough,
+						context
+					]
+				]);
+				splice(events, open - 1, index - open + 3, nextEvents);
+				index = open + nextEvents.length - 2;
+				break;
+			}
+		}
+		index = -1;
+		while (++index < events.length) if (events[index][1].type === "strikethroughSequenceTemporary") events[index][1].type = "data";
+		return events;
+	}
+	/**
+	* @this {TokenizeContext}
+	* @type {Tokenizer}
+	*/
+	function tokenizeStrikethrough(effects, ok, nok) {
+		const previous = this.previous;
+		const events = this.events;
+		let size = 0;
+		return start;
+		/** @type {State} */
+		function start(code) {
+			if (previous === 126 && events[events.length - 1][1].type !== "characterEscape") return nok(code);
+			effects.enter("strikethroughSequenceTemporary");
+			return more(code);
+		}
+		/** @type {State} */
+		function more(code) {
+			const before = classifyCharacter(previous);
+			if (code === 126) {
+				if (size > 1) return nok(code);
+				effects.consume(code);
+				size++;
+				return more;
+			}
+			if (size < 2 && !single) return nok(code);
+			const token = effects.exit("strikethroughSequenceTemporary");
+			const after = classifyCharacter(code);
+			token._open = !after || after === 2 && Boolean(before);
+			token._close = !before || before === 2 && Boolean(after);
+			return ok(code);
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/edit-map.js
+/**
+* @import {Event} from 'micromark-util-types'
+*/
+/**
+* @typedef {[number, number, Array<Event>]} Change
+* @typedef {[number, number, number]} Jump
+*/
+/**
+* Tracks a bunch of edits.
+*/
+var EditMap = class {
+	/**
+	* Create a new edit map.
+	*/
+	constructor() {
+		/**
+		* Record of changes.
+		*
+		* @type {Array<Change>}
+		*/
+		this.map = [];
+	}
+	/**
+	* Create an edit: a remove and/or add at a certain place.
+	*
+	* @param {number} index
+	* @param {number} remove
+	* @param {Array<Event>} add
+	* @returns {undefined}
+	*/
+	add(index, remove, add) {
+		addImplementation(this, index, remove, add);
+	}
+	/**
+	* Done, change the events.
+	*
+	* @param {Array<Event>} events
+	* @returns {undefined}
+	*/
+	consume(events) {
+		this.map.sort(function(a, b) {
+			return a[0] - b[0];
+		});
+		/* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
+		if (this.map.length === 0) return;
+		let index = this.map.length;
+		/** @type {Array<Array<Event>>} */
+		const vecs = [];
+		while (index > 0) {
+			index -= 1;
+			vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);
+			events.length = this.map[index][0];
+		}
+		vecs.push(events.slice());
+		events.length = 0;
+		let slice = vecs.pop();
+		while (slice) {
+			for (const element of slice) events.push(element);
+			slice = vecs.pop();
+		}
+		this.map.length = 0;
+	}
+};
+/**
+* Create an edit.
+*
+* @param {EditMap} editMap
+* @param {number} at
+* @param {number} remove
+* @param {Array<Event>} add
+* @returns {undefined}
+*/
+function addImplementation(editMap, at, remove, add) {
+	let index = 0;
+	/* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
+	if (remove === 0 && add.length === 0) return;
+	while (index < editMap.map.length) {
+		if (editMap.map[index][0] === at) {
+			editMap.map[index][1] += remove;
+			editMap.map[index][2].push(...add);
+			return;
+		}
+		index += 1;
+	}
+	editMap.map.push([
+		at,
+		remove,
+		add
+	]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/infer.js
+/**
+* @import {Event} from 'micromark-util-types'
+*/
+/**
+* @typedef {'center' | 'left' | 'none' | 'right'} Align
+*/
+/**
+* Figure out the alignment of a GFM table.
+*
+* @param {Readonly<Array<Event>>} events
+*   List of events.
+* @param {number} index
+*   Table enter event.
+* @returns {Array<Align>}
+*   List of aligns.
+*/
+function gfmTableAlign(events, index) {
+	let inDelimiterRow = false;
+	/** @type {Array<Align>} */
+	const align = [];
+	while (index < events.length) {
+		const event = events[index];
+		if (inDelimiterRow) {
+			if (event[0] === "enter") {
+				if (event[1].type === "tableContent") align.push(events[index + 1][1].type === "tableDelimiterMarker" ? "left" : "none");
+			} else if (event[1].type === "tableContent") {
+				if (events[index - 1][1].type === "tableDelimiterMarker") {
+					const alignIndex = align.length - 1;
+					align[alignIndex] = align[alignIndex] === "left" ? "center" : "right";
+				}
+			} else if (event[1].type === "tableDelimiterRow") break;
+		} else if (event[0] === "enter" && event[1].type === "tableDelimiterRow") inDelimiterRow = true;
+		index += 1;
+	}
+	return align;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/syntax.js
+/**
+* @import {Event, Extension, Point, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+/**
+* @typedef {[number, number, number, number]} Range
+*   Cell info.
+*
+* @typedef {0 | 1 | 2 | 3} RowKind
+*   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.
+*/
+/**
+* Create an HTML extension for `micromark` to support GitHub tables syntax.
+*
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `extensions` to enable GFM
+*   table syntax.
+*/
+function gfmTable() {
+	return { flow: { null: {
+		name: "table",
+		tokenize: tokenizeTable,
+		resolveAll: resolveTable
+	} } };
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeTable(effects, ok, nok) {
+	const self = this;
+	let size = 0;
+	let sizeB = 0;
+	/** @type {boolean | undefined} */
+	let seen;
+	return start;
+	/**
+	* Start of a GFM table.
+	*
+	* If there is a valid table row or table head before, then we try to parse
+	* another row.
+	* Otherwise, we try to parse a head.
+	*
+	* ```markdown
+	* > | | a |
+	*     ^
+	*   | | - |
+	* > | | b |
+	*     ^
+	* ```
+	* @type {State}
+	*/
+	function start(code) {
+		let index = self.events.length - 1;
+		while (index > -1) {
+			const type = self.events[index][1].type;
+			if (type === "lineEnding" || type === "linePrefix") index--;
+			else break;
+		}
+		const tail = index > -1 ? self.events[index][1].type : null;
+		const next = tail === "tableHead" || tail === "tableRow" ? bodyRowStart : headRowBefore;
+		if (next === bodyRowStart && self.parser.lazy[self.now().line]) return nok(code);
+		return next(code);
+	}
+	/**
+	* Before table head row.
+	*
+	* ```markdown
+	* > | | a |
+	*     ^
+	*   | | - |
+	*   | | b |
+	* ```
+	*
+	* @type {State}
+	*/
+	function headRowBefore(code) {
+		effects.enter("tableHead");
+		effects.enter("tableRow");
+		return headRowStart(code);
+	}
+	/**
+	* Before table head row, after whitespace.
+	*
+	* ```markdown
+	* > | | a |
+	*     ^
+	*   | | - |
+	*   | | b |
+	* ```
+	*
+	* @type {State}
+	*/
+	function headRowStart(code) {
+		if (code === 124) return headRowBreak(code);
+		seen = true;
+		sizeB += 1;
+		return headRowBreak(code);
+	}
+	/**
+	* At break in table head row.
+	*
+	* ```markdown
+	* > | | a |
+	*     ^
+	*       ^
+	*         ^
+	*   | | - |
+	*   | | b |
+	* ```
+	*
+	* @type {State}
+	*/
+	function headRowBreak(code) {
+		if (code === null) return nok(code);
+		if (markdownLineEnding(code)) {
+			if (sizeB > 1) {
+				sizeB = 0;
+				self.interrupt = true;
+				effects.exit("tableRow");
+				effects.enter("lineEnding");
+				effects.consume(code);
+				effects.exit("lineEnding");
+				return headDelimiterStart;
+			}
+			return nok(code);
+		}
+		if (markdownSpace(code)) return factorySpace(effects, headRowBreak, "whitespace")(code);
+		sizeB += 1;
+		if (seen) {
+			seen = false;
+			size += 1;
+		}
+		if (code === 124) {
+			effects.enter("tableCellDivider");
+			effects.consume(code);
+			effects.exit("tableCellDivider");
+			seen = true;
+			return headRowBreak;
+		}
+		effects.enter("data");
+		return headRowData(code);
+	}
+	/**
+	* In table head row data.
+	*
+	* ```markdown
+	* > | | a |
+	*       ^
+	*   | | - |
+	*   | | b |
+	* ```
+	*
+	* @type {State}
+	*/
+	function headRowData(code) {
+		if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
+			effects.exit("data");
+			return headRowBreak(code);
+		}
+		effects.consume(code);
+		return code === 92 ? headRowEscape : headRowData;
+	}
+	/**
+	* In table head row escape.
+	*
+	* ```markdown
+	* > | | a\-b |
+	*         ^
+	*   | | ---- |
+	*   | | c    |
+	* ```
+	*
+	* @type {State}
+	*/
+	function headRowEscape(code) {
+		if (code === 92 || code === 124) {
+			effects.consume(code);
+			return headRowData;
+		}
+		return headRowData(code);
+	}
+	/**
+	* Before delimiter row.
+	*
+	* ```markdown
+	*   | | a |
+	* > | | - |
+	*     ^
+	*   | | b |
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterStart(code) {
+		self.interrupt = false;
+		if (self.parser.lazy[self.now().line]) return nok(code);
+		effects.enter("tableDelimiterRow");
+		seen = false;
+		if (markdownSpace(code)) return factorySpace(effects, headDelimiterBefore, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code);
+		return headDelimiterBefore(code);
+	}
+	/**
+	* Before delimiter row, after optional whitespace.
+	*
+	* Reused when a `|` is found later, to parse another cell.
+	*
+	* ```markdown
+	*   | | a |
+	* > | | - |
+	*     ^
+	*   | | b |
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterBefore(code) {
+		if (code === 45 || code === 58) return headDelimiterValueBefore(code);
+		if (code === 124) {
+			seen = true;
+			effects.enter("tableCellDivider");
+			effects.consume(code);
+			effects.exit("tableCellDivider");
+			return headDelimiterCellBefore;
+		}
+		return headDelimiterNok(code);
+	}
+	/**
+	* After `|`, before delimiter cell.
+	*
+	* ```markdown
+	*   | | a |
+	* > | | - |
+	*      ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterCellBefore(code) {
+		if (markdownSpace(code)) return factorySpace(effects, headDelimiterValueBefore, "whitespace")(code);
+		return headDelimiterValueBefore(code);
+	}
+	/**
+	* Before delimiter cell value.
+	*
+	* ```markdown
+	*   | | a |
+	* > | | - |
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterValueBefore(code) {
+		if (code === 58) {
+			sizeB += 1;
+			seen = true;
+			effects.enter("tableDelimiterMarker");
+			effects.consume(code);
+			effects.exit("tableDelimiterMarker");
+			return headDelimiterLeftAlignmentAfter;
+		}
+		if (code === 45) {
+			sizeB += 1;
+			return headDelimiterLeftAlignmentAfter(code);
+		}
+		if (code === null || markdownLineEnding(code)) return headDelimiterCellAfter(code);
+		return headDelimiterNok(code);
+	}
+	/**
+	* After delimiter cell left alignment marker.
+	*
+	* ```markdown
+	*   | | a  |
+	* > | | :- |
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterLeftAlignmentAfter(code) {
+		if (code === 45) {
+			effects.enter("tableDelimiterFiller");
+			return headDelimiterFiller(code);
+		}
+		return headDelimiterNok(code);
+	}
+	/**
+	* In delimiter cell filler.
+	*
+	* ```markdown
+	*   | | a |
+	* > | | - |
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterFiller(code) {
+		if (code === 45) {
+			effects.consume(code);
+			return headDelimiterFiller;
+		}
+		if (code === 58) {
+			seen = true;
+			effects.exit("tableDelimiterFiller");
+			effects.enter("tableDelimiterMarker");
+			effects.consume(code);
+			effects.exit("tableDelimiterMarker");
+			return headDelimiterRightAlignmentAfter;
+		}
+		effects.exit("tableDelimiterFiller");
+		return headDelimiterRightAlignmentAfter(code);
+	}
+	/**
+	* After delimiter cell right alignment marker.
+	*
+	* ```markdown
+	*   | |  a |
+	* > | | -: |
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterRightAlignmentAfter(code) {
+		if (markdownSpace(code)) return factorySpace(effects, headDelimiterCellAfter, "whitespace")(code);
+		return headDelimiterCellAfter(code);
+	}
+	/**
+	* After delimiter cell.
+	*
+	* ```markdown
+	*   | |  a |
+	* > | | -: |
+	*          ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterCellAfter(code) {
+		if (code === 124) return headDelimiterBefore(code);
+		if (code === null || markdownLineEnding(code)) {
+			if (!seen || size !== sizeB) return headDelimiterNok(code);
+			effects.exit("tableDelimiterRow");
+			effects.exit("tableHead");
+			return ok(code);
+		}
+		return headDelimiterNok(code);
+	}
+	/**
+	* In delimiter row, at a disallowed byte.
+	*
+	* ```markdown
+	*   | | a |
+	* > | | x |
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function headDelimiterNok(code) {
+		return nok(code);
+	}
+	/**
+	* Before table body row.
+	*
+	* ```markdown
+	*   | | a |
+	*   | | - |
+	* > | | b |
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function bodyRowStart(code) {
+		effects.enter("tableRow");
+		return bodyRowBreak(code);
+	}
+	/**
+	* At break in table body row.
+	*
+	* ```markdown
+	*   | | a |
+	*   | | - |
+	* > | | b |
+	*     ^
+	*       ^
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function bodyRowBreak(code) {
+		if (code === 124) {
+			effects.enter("tableCellDivider");
+			effects.consume(code);
+			effects.exit("tableCellDivider");
+			return bodyRowBreak;
+		}
+		if (code === null || markdownLineEnding(code)) {
+			effects.exit("tableRow");
+			return ok(code);
+		}
+		if (markdownSpace(code)) return factorySpace(effects, bodyRowBreak, "whitespace")(code);
+		effects.enter("data");
+		return bodyRowData(code);
+	}
+	/**
+	* In table body row data.
+	*
+	* ```markdown
+	*   | | a |
+	*   | | - |
+	* > | | b |
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function bodyRowData(code) {
+		if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
+			effects.exit("data");
+			return bodyRowBreak(code);
+		}
+		effects.consume(code);
+		return code === 92 ? bodyRowEscape : bodyRowData;
+	}
+	/**
+	* In table body row escape.
+	*
+	* ```markdown
+	*   | | a    |
+	*   | | ---- |
+	* > | | b\-c |
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function bodyRowEscape(code) {
+		if (code === 92 || code === 124) {
+			effects.consume(code);
+			return bodyRowData;
+		}
+		return bodyRowData(code);
+	}
+}
+/** @type {Resolver} */
+function resolveTable(events, context) {
+	let index = -1;
+	let inFirstCellAwaitingPipe = true;
+	/** @type {RowKind} */
+	let rowKind = 0;
+	/** @type {Range} */
+	let lastCell = [
+		0,
+		0,
+		0,
+		0
+	];
+	/** @type {Range} */
+	let cell = [
+		0,
+		0,
+		0,
+		0
+	];
+	let afterHeadAwaitingFirstBodyRow = false;
+	let lastTableEnd = 0;
+	/** @type {Token | undefined} */
+	let currentTable;
+	/** @type {Token | undefined} */
+	let currentBody;
+	/** @type {Token | undefined} */
+	let currentCell;
+	const map = new EditMap();
+	while (++index < events.length) {
+		const event = events[index];
+		const token = event[1];
+		if (event[0] === "enter") {
+			if (token.type === "tableHead") {
+				afterHeadAwaitingFirstBodyRow = false;
+				if (lastTableEnd !== 0) {
+					flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);
+					currentBody = void 0;
+					lastTableEnd = 0;
+				}
+				currentTable = {
+					type: "table",
+					start: Object.assign({}, token.start),
+					end: Object.assign({}, token.end)
+				};
+				map.add(index, 0, [[
+					"enter",
+					currentTable,
+					context
+				]]);
+			} else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
+				inFirstCellAwaitingPipe = true;
+				currentCell = void 0;
+				lastCell = [
+					0,
+					0,
+					0,
+					0
+				];
+				cell = [
+					0,
+					index + 1,
+					0,
+					0
+				];
+				if (afterHeadAwaitingFirstBodyRow) {
+					afterHeadAwaitingFirstBodyRow = false;
+					currentBody = {
+						type: "tableBody",
+						start: Object.assign({}, token.start),
+						end: Object.assign({}, token.end)
+					};
+					map.add(index, 0, [[
+						"enter",
+						currentBody,
+						context
+					]]);
+				}
+				rowKind = token.type === "tableDelimiterRow" ? 2 : currentBody ? 3 : 1;
+			} else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
+				inFirstCellAwaitingPipe = false;
+				if (cell[2] === 0) {
+					if (lastCell[1] !== 0) {
+						cell[0] = cell[1];
+						currentCell = flushCell(map, context, lastCell, rowKind, void 0, currentCell);
+						lastCell = [
+							0,
+							0,
+							0,
+							0
+						];
+					}
+					cell[2] = index;
+				}
+			} else if (token.type === "tableCellDivider") if (inFirstCellAwaitingPipe) inFirstCellAwaitingPipe = false;
+			else {
+				if (lastCell[1] !== 0) {
+					cell[0] = cell[1];
+					currentCell = flushCell(map, context, lastCell, rowKind, void 0, currentCell);
+				}
+				lastCell = cell;
+				cell = [
+					lastCell[1],
+					index,
+					0,
+					0
+				];
+			}
+		} else if (token.type === "tableHead") {
+			afterHeadAwaitingFirstBodyRow = true;
+			lastTableEnd = index;
+		} else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
+			lastTableEnd = index;
+			if (lastCell[1] !== 0) {
+				cell[0] = cell[1];
+				currentCell = flushCell(map, context, lastCell, rowKind, index, currentCell);
+			} else if (cell[1] !== 0) currentCell = flushCell(map, context, cell, rowKind, index, currentCell);
+			rowKind = 0;
+		} else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) cell[3] = index;
+	}
+	if (lastTableEnd !== 0) flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);
+	map.consume(context.events);
+	index = -1;
+	while (++index < context.events.length) {
+		const event = context.events[index];
+		if (event[0] === "enter" && event[1].type === "table") event[1]._align = gfmTableAlign(context.events, index);
+	}
+	return events;
+}
+/**
+* Generate a cell.
+*
+* @param {EditMap} map
+* @param {Readonly<TokenizeContext>} context
+* @param {Readonly<Range>} range
+* @param {RowKind} rowKind
+* @param {number | undefined} rowEnd
+* @param {Token | undefined} previousCell
+* @returns {Token | undefined}
+*/
+function flushCell(map, context, range, rowKind, rowEnd, previousCell) {
+	const groupName = rowKind === 1 ? "tableHeader" : rowKind === 2 ? "tableDelimiter" : "tableData";
+	const valueName = "tableContent";
+	if (range[0] !== 0) {
+		previousCell.end = Object.assign({}, getPoint(context.events, range[0]));
+		map.add(range[0], 0, [[
+			"exit",
+			previousCell,
+			context
+		]]);
+	}
+	const now = getPoint(context.events, range[1]);
+	previousCell = {
+		type: groupName,
+		start: Object.assign({}, now),
+		end: Object.assign({}, now)
+	};
+	map.add(range[1], 0, [[
+		"enter",
+		previousCell,
+		context
+	]]);
+	if (range[2] !== 0) {
+		const relatedStart = getPoint(context.events, range[2]);
+		const relatedEnd = getPoint(context.events, range[3]);
+		/** @type {Token} */
+		const valueToken = {
+			type: valueName,
+			start: Object.assign({}, relatedStart),
+			end: Object.assign({}, relatedEnd)
+		};
+		map.add(range[2], 0, [[
+			"enter",
+			valueToken,
+			context
+		]]);
+		if (rowKind !== 2) {
+			const start = context.events[range[2]];
+			const end = context.events[range[3]];
+			start[1].end = Object.assign({}, end[1].end);
+			start[1].type = "chunkText";
+			start[1].contentType = "text";
+			if (range[3] > range[2] + 1) {
+				const a = range[2] + 1;
+				const b = range[3] - range[2] - 1;
+				map.add(a, b, []);
+			}
+		}
+		map.add(range[3] + 1, 0, [[
+			"exit",
+			valueToken,
+			context
+		]]);
+	}
+	if (rowEnd !== void 0) {
+		previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));
+		map.add(rowEnd, 0, [[
+			"exit",
+			previousCell,
+			context
+		]]);
+		previousCell = void 0;
+	}
+	return previousCell;
+}
+/**
+* Generate table end (and table body end).
+*
+* @param {Readonly<EditMap>} map
+* @param {Readonly<TokenizeContext>} context
+* @param {number} index
+* @param {Token} table
+* @param {Token | undefined} tableBody
+*/
+function flushTableEnd(map, context, index, table, tableBody) {
+	/** @type {Array<Event>} */
+	const exits = [];
+	const related = getPoint(context.events, index);
+	if (tableBody) {
+		tableBody.end = Object.assign({}, related);
+		exits.push([
+			"exit",
+			tableBody,
+			context
+		]);
+	}
+	table.end = Object.assign({}, related);
+	exits.push([
+		"exit",
+		table,
+		context
+	]);
+	map.add(index + 1, 0, exits);
+}
+/**
+* @param {Readonly<Array<Event>>} events
+* @param {number} index
+* @returns {Readonly<Point>}
+*/
+function getPoint(events, index) {
+	const event = events[index];
+	const side = event[0] === "enter" ? "start" : "end";
+	return event[1][side];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/micromark-extension-gfm-task-list-item@2.1.0/node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js
+/**
+* @import {Extension, State, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+var tasklistCheck = {
+	name: "tasklistCheck",
+	tokenize: tokenizeTasklistCheck
+};
+/**
+* Create an HTML extension for `micromark` to support GFM task list items
+* syntax.
+*
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `htmlExtensions` to
+*   support GFM task list items when serializing to HTML.
+*/
+function gfmTaskListItem() {
+	return { text: { [91]: tasklistCheck } };
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeTasklistCheck(effects, ok, nok) {
+	const self = this;
+	return open;
+	/**
+	* At start of task list item check.
+	*
+	* ```markdown
+	* > | * [x] y.
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function open(code) {
+		if (self.previous !== null || !self._gfmTasklistFirstContentOfListItem) return nok(code);
+		effects.enter("taskListCheck");
+		effects.enter("taskListCheckMarker");
+		effects.consume(code);
+		effects.exit("taskListCheckMarker");
+		return inside;
+	}
+	/**
+	* In task list item check.
+	*
+	* ```markdown
+	* > | * [x] y.
+	*        ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function inside(code) {
+		if (markdownLineEndingOrSpace(code)) {
+			effects.enter("taskListCheckValueUnchecked");
+			effects.consume(code);
+			effects.exit("taskListCheckValueUnchecked");
+			return close;
+		}
+		if (code === 88 || code === 120) {
+			effects.enter("taskListCheckValueChecked");
+			effects.consume(code);
+			effects.exit("taskListCheckValueChecked");
+			return close;
+		}
+		return nok(code);
+	}
+	/**
+	* At close of task list item check.
+	*
+	* ```markdown
+	* > | * [x] y.
+	*         ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function close(code) {
+		if (code === 93) {
+			effects.enter("taskListCheckMarker");
+			effects.consume(code);
+			effects.exit("taskListCheckMarker");
+			effects.exit("taskListCheck");
+			return after;
+		}
+		return nok(code);
+	}
+	/**
+	* @type {State}
+	*/
+	function after(code) {
+		if (markdownLineEnding(code)) return ok(code);
+		if (markdownSpace(code)) return effects.check({ tokenize: spaceThenNonSpace }, ok, nok)(code);
+		return nok(code);
+	}
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function spaceThenNonSpace(effects, ok, nok) {
+	return factorySpace(effects, after, "whitespace");
+	/**
+	* After whitespace, after task list item check.
+	*
+	* ```markdown
+	* > | * [x] y.
+	*           ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		return code === null ? nok(code) : ok(code);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/micromark-extension-gfm@3.0.0/node_modules/micromark-extension-gfm/index.js
+/**
+* @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions
+* @typedef {import('micromark-extension-gfm-strikethrough').Options} Options
+* @typedef {import('micromark-util-types').Extension} Extension
+* @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+*/
+/**
+* Create an extension for `micromark` to enable GFM syntax.
+*
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+*
+*   Passed to `micromark-extens-gfm-strikethrough`.
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `extensions` to enable GFM
+*   syntax.
+*/
+function gfm(options) {
+	return combineExtensions([
+		gfmAutolinkLiteral(),
+		gfmFootnote(),
+		gfmStrikethrough(options),
+		gfmTable(),
+		gfmTaskListItem()
+	]);
+}
+//#endregion
+export { gfm as t };