@alivault/pico 0.14.1 → 0.16.1

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

@@ -1,2234 +0,0 @@
-import { a as factorySpace, c as asciiControl, d as markdownSpace, f as unicodePunctuation, g as splice, h as combineExtensions, i as classifyCharacter, l as markdownLineEnding, m as normalizeIdentifier, n as blankLine, o as asciiAlpha, p as unicodeWhitespace, r as resolveAll, s as asciiAlphanumeric, u as markdownLineEndingOrSpace } 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 };