@morlay/dsh-reference 0.0.1-alpha.2

package/dist/index.mjs

@@ -0,0 +1,4948 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { isUserInvocable, renderSkillContent } from "@deepseek-ai/dsh-skill";
+import { fromMarkdown } from "mdast-util-from-markdown";
+//#region src/file-content.ts
+const READ_LIMIT = 2e3;
+const READ_MAX_LINE_LENGTH = 2e3;
+const READ_MAX_BYTES = 51200;
+const STREAM_MIN_SIZE = 10485760;
+async function readFileContent(fs, reference, request) {
+	const offset = reference.lineStart ?? 1;
+	const limit = reference.lineEnd === void 0 ? READ_LIMIT : Math.max(1, reference.lineEnd - offset + 1);
+	try {
+		const target = await fs.resolve(reference.path, {
+			...request.cwd === void 0 ? {} : { cwd: request.cwd },
+			signal: request.signal
+		});
+		const info = await fs.stat(target, request.signal);
+		if (info === void 0 || info.type !== "file") return void 0;
+		const window = await buildWindow(info.size === void 0 || info.size >= STREAM_MIN_SIZE ? await fs.streamText(target, request.signal) : [await fs.readText(target, request.signal)], {
+			offset,
+			limit
+		});
+		if (window === void 0) return void 0;
+		return formatFileContent(target.displayPath, {
+			offset,
+			lines: window.lines,
+			totalLines: window.totalLines,
+			truncatedByBytes: window.truncatedByBytes
+		});
+	} catch {
+		request.signal.throwIfAborted();
+		return;
+	}
+}
+async function buildWindow(chunks, window) {
+	const lines = [];
+	let totalLines = 0;
+	let outputBytes = 0;
+	let truncatedByBytes = false;
+	let lineBuffer = "";
+	const lineBufferCap = 2001;
+	const append = (segment) => {
+		if (lineBuffer.length >= lineBufferCap) return;
+		lineBuffer += segment;
+		if (lineBuffer.length > lineBufferCap) lineBuffer = lineBuffer.slice(0, lineBufferCap);
+	};
+	const flush = () => {
+		const raw = lineBuffer.endsWith("\r") ? lineBuffer.slice(0, -1) : lineBuffer;
+		lineBuffer = "";
+		totalLines += 1;
+		if (truncatedByBytes || totalLines < window.offset || lines.length >= window.limit) return;
+		const text = raw.length > READ_MAX_LINE_LENGTH ? `${raw.slice(0, READ_MAX_LINE_LENGTH)}... (line truncated to ${READ_MAX_LINE_LENGTH} chars)` : raw;
+		const bytes = Buffer.byteLength(text, "utf8") + (lines.length > 0 ? 1 : 0);
+		if (outputBytes + bytes > READ_MAX_BYTES) {
+			truncatedByBytes = true;
+			return;
+		}
+		outputBytes += bytes;
+		lines.push({
+			number: totalLines,
+			text
+		});
+	};
+	for await (const chunk of chunks) {
+		let start = 0;
+		let newline = chunk.indexOf("\n", start);
+		while (newline !== -1) {
+			append(chunk.slice(start, newline));
+			flush();
+			start = newline + 1;
+			newline = chunk.indexOf("\n", start);
+		}
+		append(chunk.slice(start));
+	}
+	if (lineBuffer.length > 0) flush();
+	if (!truncatedByBytes && window.offset > totalLines && !(totalLines === 0 && window.offset === 1)) return void 0;
+	return {
+		lines,
+		totalLines,
+		truncatedByBytes
+	};
+}
+function formatFileContent(displayPath, outcome) {
+	const endLine = outcome.lines.at(-1)?.number ?? Math.max(0, outcome.offset - 1);
+	let footer;
+	if (outcome.truncatedByBytes) footer = `(Output capped. Showing lines ${outcome.offset}-${endLine}. Use offset=${endLine + 1} to continue.)`;
+	else if (endLine < outcome.totalLines) footer = `(Showing lines ${outcome.offset}-${endLine} of ${outcome.totalLines}. Use offset=${endLine + 1} to continue.)`;
+	else footer = `(End of file - total ${outcome.totalLines} lines)`;
+	const body = outcome.lines.length === 0 ? footer : `${outcome.lines.map((line) => `${line.number}: ${line.text}`).join("\n")}\n\n${footer}`;
+	return `<file_content path="${displayPath.replaceAll("\"", "&quot;")}">
+${body}
+</file_content>`;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js
+/**
+* Count how often a character (or substring) is used in a string.
+*
+* @param {string} value
+*   Value to search in.
+* @param {string} character
+*   Character (or substring) to look for.
+* @return {number}
+*   Number of times `character` occurred in `value`.
+*/
+function ccount(value, character) {
+	const source = String(value);
+	if (typeof character !== "string") throw new TypeError("Expected character");
+	let count = 0;
+	let index = source.indexOf(character);
+	while (index !== -1) {
+		count++;
+		index = source.indexOf(character, index + character.length);
+	}
+	return count;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.js
+/**
+* @import {Code} from 'micromark-util-types'
+*/
+/**
+* Check whether the character code represents an ASCII alpha (`a` through `z`,
+* case insensitive).
+*
+* An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+*
+* An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+* to U+005A (`Z`).
+*
+* An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+* to U+007A (`z`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiAlpha = regexCheck(/[A-Za-z]/);
+/**
+* Check whether the character code represents an ASCII alphanumeric (`a`
+* through `z`, case insensitive, or `0` through `9`).
+*
+* An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+* (see `asciiAlpha`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+/**
+* Check whether a character code is an ASCII control character.
+*
+* An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+* to U+001F (US), or U+007F (DEL).
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function asciiControl(code) {
+	return code !== null && (code < 32 || code === 127);
+}
+/**
+* Check whether the character code represents an ASCII digit (`0` through `9`).
+*
+* An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+* U+0039 (`9`).
+*
+* @param code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+const asciiDigit = regexCheck(/\d/);
+/**
+* Check whether a character code is a markdown line ending.
+*
+* A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+* LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+*
+* In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+* RETURN (CR) are replaced by these virtual characters depending on whether
+* they occurred together.
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownLineEnding(code) {
+	return code !== null && code < -2;
+}
+/**
+* Check whether a character code is a markdown line ending (see
+* `markdownLineEnding`) or markdown space (see `markdownSpace`).
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownLineEndingOrSpace(code) {
+	return code !== null && (code < 0 || code === 32);
+}
+/**
+* Check whether a character code is a markdown space.
+*
+* A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+* virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+*
+* In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+* replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+* SPACE (VS) characters, depending on the column at which the tab occurred.
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownSpace(code) {
+	return code === -2 || code === -1 || code === 32;
+}
+/**
+* Check whether the character code represents Unicode punctuation.
+*
+* A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+* Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+* (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+* (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+* punctuation (see `asciiPunctuation`).
+*
+* See:
+* **\[UNICODE]**:
+* [The Unicode Standard](https://www.unicode.org/versions/).
+* Unicode Consortium.
+*
+* @param code
+*   Code.
+* @returns
+*   Whether it matches.
+*/
+const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
+/**
+* Check whether the character code represents Unicode whitespace.
+*
+* Note that this does handle micromark specific markdown whitespace characters.
+* See `markdownLineEndingOrSpace` to check that.
+*
+* A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+* Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+* U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+*
+* See:
+* **\[UNICODE]**:
+* [The Unicode Standard](https://www.unicode.org/versions/).
+* Unicode Consortium.
+*
+* @param code
+*   Code.
+* @returns
+*   Whether it matches.
+*/
+const unicodeWhitespace = regexCheck(/\s/);
+/**
+* Create a code check from a regex.
+*
+* @param {RegExp} regex
+*   Expression.
+* @returns {(code: Code) => boolean}
+*   Check.
+*/
+function regexCheck(regex) {
+	return check;
+	/**
+	* Check whether a code matches the bound regex.
+	*
+	* @param {Code} code
+	*   Character code.
+	* @returns {boolean}
+	*   Whether the character code matches the bound regex.
+	*/
+	function check(code) {
+		return code !== null && code > -1 && regex.test(String.fromCharCode(code));
+	}
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
+function escapeStringRegexp(string) {
+	if (typeof string !== "string") throw new TypeError("Expected a string");
+	return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/unist-util-is@6.0.1/node_modules/unist-util-is/lib/index.js
+/**
+* Generate an assertion from a test.
+*
+* Useful if you’re going to test many nodes, for example when creating a
+* utility where something else passes a compatible test.
+*
+* The created function is a bit faster because it expects valid input only:
+* a `node`, `index`, and `parent`.
+*
+* @param {Test} test
+*   *   when nullish, checks if `node` is a `Node`.
+*   *   when `string`, works like passing `(node) => node.type === test`.
+*   *   when `function` checks if function passed the node is true.
+*   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+*   *   when `array`, checks if any one of the subtests pass.
+* @returns {Check}
+*   An assertion.
+*/
+const convert = (
+/**
+* @param {Test} [test]
+* @returns {Check}
+*/
+function(test) {
+	if (test === null || test === void 0) return ok;
+	if (typeof test === "function") return castFactory(test);
+	if (typeof test === "object") return Array.isArray(test) ? anyFactory(test) : propertiesFactory(test);
+	if (typeof test === "string") return typeFactory(test);
+	throw new Error("Expected function, string, or object as test");
+});
+/**
+* @param {Array<Props | TestFunction | string>} tests
+* @returns {Check}
+*/
+function anyFactory(tests) {
+	/** @type {Array<Check>} */
+	const checks = [];
+	let index = -1;
+	while (++index < tests.length) checks[index] = convert(tests[index]);
+	return castFactory(any);
+	/**
+	* @this {unknown}
+	* @type {TestFunction}
+	*/
+	function any(...parameters) {
+		let index = -1;
+		while (++index < checks.length) if (checks[index].apply(this, parameters)) return true;
+		return false;
+	}
+}
+/**
+* Turn an object into a test for a node with a certain fields.
+*
+* @param {Props} check
+* @returns {Check}
+*/
+function propertiesFactory(check) {
+	const checkAsRecord = check;
+	return castFactory(all);
+	/**
+	* @param {Node} node
+	* @returns {boolean}
+	*/
+	function all(node) {
+		const nodeAsRecord = node;
+		/** @type {string} */
+		let key;
+		for (key in check) if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
+		return true;
+	}
+}
+/**
+* Turn a string into a test for a node with a certain type.
+*
+* @param {string} check
+* @returns {Check}
+*/
+function typeFactory(check) {
+	return castFactory(type);
+	/**
+	* @param {Node} node
+	*/
+	function type(node) {
+		return node && node.type === check;
+	}
+}
+/**
+* Turn a custom test into a test for a node that passes that test.
+*
+* @param {TestFunction} testFunction
+* @returns {Check}
+*/
+function castFactory(testFunction) {
+	return check;
+	/**
+	* @this {unknown}
+	* @type {Check}
+	*/
+	function check(value, index, parent) {
+		return Boolean(looksLikeANode(value) && testFunction.call(this, value, typeof index === "number" ? index : void 0, parent || void 0));
+	}
+}
+function ok() {
+	return true;
+}
+/**
+* @param {unknown} value
+* @returns {value is Node}
+*/
+function looksLikeANode(value) {
+	return value !== null && typeof value === "object" && "type" in value;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/unist-util-visit-parents@6.0.2/node_modules/unist-util-visit-parents/lib/color.node.js
+/**
+* @param {string} d
+* @returns {string}
+*/
+function color(d) {
+	return "\x1B[33m" + d + "\x1B[39m";
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/unist-util-visit-parents@6.0.2/node_modules/unist-util-visit-parents/lib/index.js
+/**
+* @import {Node as UnistNode, Parent as UnistParent} from 'unist'
+*/
+/**
+* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+*   Test from `unist-util-is`.
+*
+*   Note: we have remove and add `undefined`, because otherwise when generating
+*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+*   which doesn’t work when publishing on npm.
+*/
+/**
+* @typedef {(
+*   Fn extends (value: any) => value is infer Thing
+*   ? Thing
+*   : Fallback
+* )} Predicate
+*   Get the value of a type guard `Fn`.
+* @template Fn
+*   Value; typically function that is a type guard (such as `(x): x is Y`).
+* @template Fallback
+*   Value to yield if `Fn` is not a type guard.
+*/
+/**
+* @typedef {(
+*   Check extends null | undefined // No test.
+*   ? Value
+*   : Value extends {type: Check} // String (type) test.
+*   ? Value
+*   : Value extends Check // Partial test.
+*   ? Value
+*   : Check extends Function // Function test.
+*   ? Predicate<Check, Value> extends Value
+*     ? Predicate<Check, Value>
+*     : never
+*   : never // Some other test?
+* )} MatchesOne
+*   Check whether a node matches a primitive check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test, but not arrays.
+*/
+/**
+* @typedef {(
+*   Check extends ReadonlyArray<infer T>
+*   ? MatchesOne<Value, T>
+*   : Check extends Array<infer T>
+*   ? MatchesOne<Value, T>
+*   : MatchesOne<Value, Check>
+* )} Matches
+*   Check whether a node matches a check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test.
+*/
+/**
+* @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
+*   Number; capped reasonably.
+*/
+/**
+* @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
+*   Increment a number in the type system.
+* @template {Uint} [I=0]
+*   Index.
+*/
+/**
+* @typedef {(
+*   Node extends UnistParent
+*   ? Node extends {children: Array<infer Children>}
+*     ? Child extends Children ? Node : never
+*     : never
+*   : never
+* )} InternalParent
+*   Collect nodes that can be parents of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent
+*   Collect nodes in `Tree` that can be parents of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Depth extends Max
+*   ? never
+*   :
+*     | InternalParent<Node, Child>
+*     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
+* )} InternalAncestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Tree extends UnistParent
+*     ? Depth extends Max
+*       ? Tree
+*       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
+*     : Tree
+* )} InclusiveDescendant
+*   Collect all (inclusive) descendants of `Tree`.
+*
+*   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
+*   > recurse without actually running into an infinite loop, which the
+*   > previous version did.
+*   >
+*   > Practically, a max of `2` is typically enough assuming a `Root` is
+*   > passed, but it doesn’t improve performance.
+*   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
+*   > Using up to `10` doesn’t hurt or help either.
+* @template {UnistNode} Tree
+*   Tree type.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {'skip' | boolean} Action
+*   Union of the action types.
+*
+* @typedef {number} Index
+*   Move to the sibling at `index` next (after node itself is completely
+*   traversed).
+*
+*   Useful if mutating the tree, such as removing the node the visitor is
+*   currently on, or any of its previous siblings.
+*   Results less than 0 or greater than or equal to `children.length` stop
+*   traversing the parent.
+*
+* @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple
+*   List with one or two values, the first an action, the second an index.
+*
+* @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult
+*   Any value that can be returned from a visitor.
+*/
+/**
+* @callback Visitor
+*   Handle a node (matching `test`, if given).
+*
+*   Visitors are free to transform `node`.
+*   They can also transform the parent of node (the last of `ancestors`).
+*
+*   Replacing `node` itself, if `SKIP` is not returned, still causes its
+*   descendants to be walked (which is a bug).
+*
+*   When adding or removing previous siblings of `node` (or next siblings, in
+*   case of reverse), the `Visitor` should return a new `Index` to specify the
+*   sibling to traverse after `node` is traversed.
+*   Adding or removing next siblings of `node` (or previous siblings, in case
+*   of reverse) is handled as expected without needing to return a new `Index`.
+*
+*   Removing the children property of an ancestor still results in them being
+*   traversed.
+* @param {Visited} node
+*   Found node.
+* @param {Array<VisitedParents>} ancestors
+*   Ancestors of `node`.
+* @returns {VisitorResult}
+*   What to do next.
+*
+*   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
+*   An `Action` is treated as a tuple of `[Action]`.
+*
+*   Passing a tuple back only makes sense if the `Action` is `SKIP`.
+*   When the `Action` is `EXIT`, that action can be returned.
+*   When the `Action` is `CONTINUE`, `Index` can be returned.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [VisitedParents=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor
+*   Build a typed `Visitor` function from a tree and a test.
+*
+*   It will infer which values are passed as `node` and which as `parents`.
+* @template {UnistNode} [Tree=UnistNode]
+*   Tree type.
+* @template {Test} [Check=Test]
+*   Test type.
+*/
+/** @type {Readonly<ActionTuple>} */
+const empty = [];
+/**
+* Visit nodes, with ancestral information.
+*
+* This algorithm performs *depth-first* *tree traversal* in *preorder*
+* (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+*
+* You can choose for which nodes `visitor` is called by passing a `test`.
+* For complex tests, you should test yourself in `visitor`, as it will be
+* faster and will have improved type information.
+*
+* Walking the tree is an intensive task.
+* Make use of the return values of the visitor when possible.
+* Instead of walking a tree multiple times, walk it once, use `unist-util-is`
+* to check if a node matches, and then perform different operations.
+*
+* You can change the tree.
+* See `Visitor` for more info.
+*
+* @overload
+* @param {Tree} tree
+* @param {Check} check
+* @param {BuildVisitor<Tree, Check>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @overload
+* @param {Tree} tree
+* @param {BuildVisitor<Tree>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @param {UnistNode} tree
+*   Tree to traverse.
+* @param {Visitor | Test} test
+*   `unist-util-is`-compatible test
+* @param {Visitor | boolean | null | undefined} [visitor]
+*   Handle each node.
+* @param {boolean | null | undefined} [reverse]
+*   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+* @returns {undefined}
+*   Nothing.
+*
+* @template {UnistNode} Tree
+*   Node type.
+* @template {Test} Check
+*   `unist-util-is`-compatible test.
+*/
+function visitParents(tree, test, visitor, reverse) {
+	/** @type {Test} */
+	let check;
+	if (typeof test === "function" && typeof visitor !== "function") {
+		reverse = visitor;
+		visitor = test;
+	} else check = test;
+	const is = convert(check);
+	const step = reverse ? -1 : 1;
+	factory(tree, void 0, [])();
+	/**
+	* @param {UnistNode} node
+	* @param {number | undefined} index
+	* @param {Array<UnistParent>} parents
+	*/
+	function factory(node, index, parents) {
+		const value = node && typeof node === "object" ? node : {};
+		if (typeof value.type === "string") {
+			const name = typeof value.tagName === "string" ? value.tagName : typeof value.name === "string" ? value.name : void 0;
+			Object.defineProperty(visit, "name", { value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")" });
+		}
+		return visit;
+		function visit() {
+			/** @type {Readonly<ActionTuple>} */
+			let result = empty;
+			/** @type {Readonly<ActionTuple>} */
+			let subresult;
+			/** @type {number} */
+			let offset;
+			/** @type {Array<UnistParent>} */
+			let grandparents;
+			if (!test || is(node, index, parents[parents.length - 1] || void 0)) {
+				result = toResult(visitor(node, parents));
+				if (result[0] === false) return result;
+			}
+			if ("children" in node && node.children) {
+				const nodeAsParent = node;
+				if (nodeAsParent.children && result[0] !== "skip") {
+					offset = (reverse ? nodeAsParent.children.length : -1) + step;
+					grandparents = parents.concat(nodeAsParent);
+					while (offset > -1 && offset < nodeAsParent.children.length) {
+						const child = nodeAsParent.children[offset];
+						subresult = factory(child, offset, grandparents)();
+						if (subresult[0] === false) return subresult;
+						offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
+					}
+				}
+			}
+			return result;
+		}
+	}
+}
+/**
+* Turn a return value into a clean result.
+*
+* @param {VisitorResult} value
+*   Valid return values from visitors.
+* @returns {Readonly<ActionTuple>}
+*   Clean result.
+*/
+function toResult(value) {
+	if (Array.isArray(value)) return value;
+	if (typeof value === "number") return [true, value];
+	return value === null || value === void 0 ? empty : [value];
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/mdast-util-find-and-replace@3.0.2/node_modules/mdast-util-find-and-replace/lib/index.js
+/**
+* @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'
+* @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'
+*/
+/**
+* @typedef RegExpMatchObject
+*   Info on the match.
+* @property {number} index
+*   The index of the search at which the result was found.
+* @property {string} input
+*   A copy of the search string in the text node.
+* @property {[...Array<Parents>, Text]} stack
+*   All ancestors of the text node, where the last node is the text itself.
+*
+* @typedef {RegExp | string} Find
+*   Pattern to find.
+*
+*   Strings are escaped and then turned into global expressions.
+*
+* @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList
+*   Several find and replaces, in array form.
+*
+* @typedef {[Find, Replace?]} FindAndReplaceTuple
+*   Find and replace in tuple form.
+*
+* @typedef {ReplaceFunction | string | null | undefined} Replace
+*   Thing to replace with.
+*
+* @callback ReplaceFunction
+*   Callback called when a search matches.
+* @param {...any} parameters
+*   The parameters are the result of corresponding search expression:
+*
+*   * `value` (`string`) — whole match
+*   * `...capture` (`Array<string>`) — matches from regex capture groups
+*   * `match` (`RegExpMatchObject`) — info on the match
+* @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}
+*   Thing to replace with.
+*
+*   * when `null`, `undefined`, `''`, remove the match
+*   * …or when `false`, do not replace at all
+*   * …or when `string`, replace with a text node of that value
+*   * …or when `Node` or `Array<Node>`, replace with those nodes
+*
+* @typedef {[RegExp, ReplaceFunction]} Pair
+*   Normalized find and replace.
+*
+* @typedef {Array<Pair>} Pairs
+*   All find and replaced.
+*
+* @typedef Options
+*   Configuration.
+* @property {Test | null | undefined} [ignore]
+*   Test for which nodes to ignore (optional).
+*/
+/**
+* Find patterns in a tree and replace them.
+*
+* The algorithm searches the tree in *preorder* for complete values in `Text`
+* nodes.
+* Partial matches are not supported.
+*
+* @param {Nodes} tree
+*   Tree to change.
+* @param {FindAndReplaceList | FindAndReplaceTuple} list
+*   Patterns to find.
+* @param {Options | null | undefined} [options]
+*   Configuration (when `find` is not `Find`).
+* @returns {undefined}
+*   Nothing.
+*/
+function findAndReplace(tree, list, options) {
+	const ignored = convert((options || {}).ignore || []);
+	const pairs = toPairs(list);
+	let pairIndex = -1;
+	while (++pairIndex < pairs.length) visitParents(tree, "text", visitor);
+	/** @type {BuildVisitor<Root, 'text'>} */
+	function visitor(node, parents) {
+		let index = -1;
+		/** @type {Parents | undefined} */
+		let grandparent;
+		while (++index < parents.length) {
+			const parent = parents[index];
+			/** @type {Array<Nodes> | undefined} */
+			const siblings = grandparent ? grandparent.children : void 0;
+			if (ignored(parent, siblings ? siblings.indexOf(parent) : void 0, grandparent)) return;
+			grandparent = parent;
+		}
+		if (grandparent) return handler(node, parents);
+	}
+	/**
+	* Handle a text node which is not in an ignored parent.
+	*
+	* @param {Text} node
+	*   Text node.
+	* @param {Array<Parents>} parents
+	*   Parents.
+	* @returns {VisitorResult}
+	*   Result.
+	*/
+	function handler(node, parents) {
+		const parent = parents[parents.length - 1];
+		const find = pairs[pairIndex][0];
+		const replace = pairs[pairIndex][1];
+		let start = 0;
+		const index = parent.children.indexOf(node);
+		let change = false;
+		/** @type {Array<PhrasingContent>} */
+		let nodes = [];
+		find.lastIndex = 0;
+		let match = find.exec(node.value);
+		while (match) {
+			const position = match.index;
+			/** @type {RegExpMatchObject} */
+			const matchObject = {
+				index: match.index,
+				input: match.input,
+				stack: [...parents, node]
+			};
+			let value = replace(...match, matchObject);
+			if (typeof value === "string") value = value.length > 0 ? {
+				type: "text",
+				value
+			} : void 0;
+			if (value === false) find.lastIndex = position + 1;
+			else {
+				if (start !== position) nodes.push({
+					type: "text",
+					value: node.value.slice(start, position)
+				});
+				if (Array.isArray(value)) nodes.push(...value);
+				else if (value) nodes.push(value);
+				start = position + match[0].length;
+				change = true;
+			}
+			if (!find.global) break;
+			match = find.exec(node.value);
+		}
+		if (change) {
+			if (start < node.value.length) nodes.push({
+				type: "text",
+				value: node.value.slice(start)
+			});
+			parent.children.splice(index, 1, ...nodes);
+		} else nodes = [node];
+		return index + nodes.length;
+	}
+}
+/**
+* Turn a tuple or a list of tuples into pairs.
+*
+* @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList
+*   Schema.
+* @returns {Pairs}
+*   Clean pairs.
+*/
+function toPairs(tupleOrList) {
+	/** @type {Pairs} */
+	const result = [];
+	if (!Array.isArray(tupleOrList)) throw new TypeError("Expected find and replace tuple or list of tuples");
+	/** @type {FindAndReplaceList} */
+	const list = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
+	let index = -1;
+	while (++index < list.length) {
+		const tuple = list[index];
+		result.push([toExpression(tuple[0]), toFunction(tuple[1])]);
+	}
+	return result;
+}
+/**
+* Turn a find into an expression.
+*
+* @param {Find} find
+*   Find.
+* @returns {RegExp}
+*   Expression.
+*/
+function toExpression(find) {
+	return typeof find === "string" ? new RegExp(escapeStringRegexp(find), "g") : find;
+}
+/**
+* Turn a replace into a function.
+*
+* @param {Replace} replace
+*   Replace.
+* @returns {ReplaceFunction}
+*   Function.
+*/
+function toFunction(replace) {
+	return typeof replace === "function" ? replace : function() {
+		return replace;
+	};
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/mdast-util-gfm-autolink-literal@2.0.1/node_modules/mdast-util-gfm-autolink-literal/lib/index.js
+/**
+* @import {RegExpMatchObject, ReplaceFunction} from 'mdast-util-find-and-replace'
+* @import {CompileContext, Extension as FromMarkdownExtension, Handle as FromMarkdownHandle, Transform as FromMarkdownTransform} from 'mdast-util-from-markdown'
+* @import {ConstructName, Options as ToMarkdownExtension} from 'mdast-util-to-markdown'
+* @import {Link, PhrasingContent} from 'mdast'
+*/
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM autolink
+* literals in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.
+*/
+function gfmAutolinkLiteralFromMarkdown() {
+	return {
+		transforms: [transformGfmAutolinkLiterals],
+		enter: {
+			literalAutolink: enterLiteralAutolink,
+			literalAutolinkEmail: enterLiteralAutolinkValue,
+			literalAutolinkHttp: enterLiteralAutolinkValue,
+			literalAutolinkWww: enterLiteralAutolinkValue
+		},
+		exit: {
+			literalAutolink: exitLiteralAutolink,
+			literalAutolinkEmail: exitLiteralAutolinkEmail,
+			literalAutolinkHttp: exitLiteralAutolinkHttp,
+			literalAutolinkWww: exitLiteralAutolinkWww
+		}
+	};
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterLiteralAutolink(token) {
+	this.enter({
+		type: "link",
+		title: null,
+		url: "",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterLiteralAutolinkValue(token) {
+	this.config.enter.autolinkProtocol.call(this, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolinkHttp(token) {
+	this.config.exit.autolinkProtocol.call(this, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolinkWww(token) {
+	this.config.exit.data.call(this, token);
+	const node = this.stack[this.stack.length - 1];
+	node.type;
+	node.url = "http://" + this.sliceSerialize(token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolinkEmail(token) {
+	this.config.exit.autolinkEmail.call(this, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitLiteralAutolink(token) {
+	this.exit(token);
+}
+/** @type {FromMarkdownTransform} */
+function transformGfmAutolinkLiterals(tree) {
+	findAndReplace(tree, [[/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, findUrl], [/(?<=^|\s|\p{P}|\p{S})([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/gu, findEmail]], { ignore: ["link", "linkReference"] });
+}
+/**
+* @type {ReplaceFunction}
+* @param {string} _
+* @param {string} protocol
+* @param {string} domain
+* @param {string} path
+* @param {RegExpMatchObject} match
+* @returns {Array<PhrasingContent> | Link | false}
+*/
+function findUrl(_, protocol, domain, path, match) {
+	let prefix = "";
+	if (!previous(match)) return false;
+	if (/^w/i.test(protocol)) {
+		domain = protocol + domain;
+		protocol = "";
+		prefix = "http://";
+	}
+	if (!isCorrectDomain(domain)) return false;
+	const parts = splitUrl(domain + path);
+	if (!parts[0]) return false;
+	/** @type {Link} */
+	const result = {
+		type: "link",
+		title: null,
+		url: prefix + protocol + parts[0],
+		children: [{
+			type: "text",
+			value: protocol + parts[0]
+		}]
+	};
+	if (parts[1]) return [result, {
+		type: "text",
+		value: parts[1]
+	}];
+	return result;
+}
+/**
+* @type {ReplaceFunction}
+* @param {string} _
+* @param {string} atext
+* @param {string} label
+* @param {RegExpMatchObject} match
+* @returns {Link | false}
+*/
+function findEmail(_, atext, label, match) {
+	if (!previous(match, true) || /[-\d_]$/.test(label)) return false;
+	return {
+		type: "link",
+		title: null,
+		url: "mailto:" + atext + "@" + label,
+		children: [{
+			type: "text",
+			value: atext + "@" + label
+		}]
+	};
+}
+/**
+* @param {string} domain
+* @returns {boolean}
+*/
+function isCorrectDomain(domain) {
+	const parts = domain.split(".");
+	if (parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\d]/.test(parts[parts.length - 2]))) return false;
+	return true;
+}
+/**
+* @param {string} url
+* @returns {[string, string | undefined]}
+*/
+function splitUrl(url) {
+	const trailExec = /[!"&'),.:;<>?\]}]+$/.exec(url);
+	if (!trailExec) return [url, void 0];
+	url = url.slice(0, trailExec.index);
+	let trail = trailExec[0];
+	let closingParenIndex = trail.indexOf(")");
+	const openingParens = ccount(url, "(");
+	let closingParens = ccount(url, ")");
+	while (closingParenIndex !== -1 && openingParens > closingParens) {
+		url += trail.slice(0, closingParenIndex + 1);
+		trail = trail.slice(closingParenIndex + 1);
+		closingParenIndex = trail.indexOf(")");
+		closingParens++;
+	}
+	return [url, trail];
+}
+/**
+* @param {RegExpMatchObject} match
+* @param {boolean | null | undefined} [email=false]
+* @returns {boolean}
+*/
+function previous(match, email) {
+	const code = match.input.charCodeAt(match.index - 1);
+	return (match.index === 0 || unicodeWhitespace(code) || unicodePunctuation(code)) && (!email || code !== 47);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.js
+/**
+* Normalize an identifier (as found in references, definitions).
+*
+* Collapses markdown whitespace, trim, and then lower- and uppercase.
+*
+* Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their
+* lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different
+* uppercase character (U+0398 (`Θ`)).
+* So, to get a canonical form, we perform both lower- and uppercase.
+*
+* Using uppercase last makes sure keys will never interact with default
+* prototypal values (such as `constructor`): nothing in the prototype of
+* `Object` is uppercase.
+*
+* @param {string} value
+*   Identifier to normalize.
+* @returns {string}
+*   Normalized identifier.
+*/
+function normalizeIdentifier(value) {
+	return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/mdast-util-gfm-footnote@2.1.0_supports-color@9.4.0/node_modules/mdast-util-gfm-footnote/lib/index.js
+/**
+* @import {
+*   CompileContext,
+*   Extension as FromMarkdownExtension,
+*   Handle as FromMarkdownHandle
+* } from 'mdast-util-from-markdown'
+* @import {ToMarkdownOptions} from 'mdast-util-gfm-footnote'
+* @import {
+*   Handle as ToMarkdownHandle,
+*   Map,
+*   Options as ToMarkdownExtension
+* } from 'mdast-util-to-markdown'
+* @import {FootnoteDefinition, FootnoteReference} from 'mdast'
+*/
+footnoteReference.peek = footnoteReferencePeek;
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteCallString() {
+	this.buffer();
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteCall(token) {
+	this.enter({
+		type: "footnoteReference",
+		identifier: "",
+		label: ""
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteDefinitionLabelString() {
+	this.buffer();
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterFootnoteDefinition(token) {
+	this.enter({
+		type: "footnoteDefinition",
+		identifier: "",
+		label: "",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteCallString(token) {
+	const label = this.resume();
+	const node = this.stack[this.stack.length - 1];
+	node.type;
+	node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
+	node.label = label;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteCall(token) {
+	this.exit(token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteDefinitionLabelString(token) {
+	const label = this.resume();
+	const node = this.stack[this.stack.length - 1];
+	node.type;
+	node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
+	node.label = label;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitFootnoteDefinition(token) {
+	this.exit(token);
+}
+/** @type {ToMarkdownHandle} */
+function footnoteReferencePeek() {
+	return "[";
+}
+/**
+* @type {ToMarkdownHandle}
+* @param {FootnoteReference} node
+*/
+function footnoteReference(node, _, state, info) {
+	const tracker = state.createTracker(info);
+	let value = tracker.move("[^");
+	const exit = state.enter("footnoteReference");
+	const subexit = state.enter("reference");
+	value += tracker.move(state.safe(state.associationId(node), {
+		after: "]",
+		before: value
+	}));
+	subexit();
+	exit();
+	value += tracker.move("]");
+	return value;
+}
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM footnotes
+* in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown`.
+*/
+function gfmFootnoteFromMarkdown() {
+	return {
+		enter: {
+			gfmFootnoteCallString: enterFootnoteCallString,
+			gfmFootnoteCall: enterFootnoteCall,
+			gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
+			gfmFootnoteDefinition: enterFootnoteDefinition
+		},
+		exit: {
+			gfmFootnoteCallString: exitFootnoteCallString,
+			gfmFootnoteCall: exitFootnoteCall,
+			gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
+			gfmFootnoteDefinition: exitFootnoteDefinition
+		}
+	};
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/mdast-util-gfm-strikethrough@2.0.0_supports-color@9.4.0/node_modules/mdast-util-gfm-strikethrough/lib/index.js
+handleDelete.peek = peekDelete;
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM
+* strikethrough in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown` to enable GFM strikethrough.
+*/
+function gfmStrikethroughFromMarkdown() {
+	return {
+		canContainEols: ["delete"],
+		enter: { strikethrough: enterStrikethrough },
+		exit: { strikethrough: exitStrikethrough }
+	};
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterStrikethrough(token) {
+	this.enter({
+		type: "delete",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitStrikethrough(token) {
+	this.exit(token);
+}
+/**
+* @type {ToMarkdownHandle}
+* @param {Delete} node
+*/
+function handleDelete(node, _, state, info) {
+	const tracker = state.createTracker(info);
+	const exit = state.enter("strikethrough");
+	let value = tracker.move("~~");
+	value += state.containerPhrasing(node, {
+		...tracker.current(),
+		before: value,
+		after: "~"
+	});
+	value += tracker.move("~~");
+	exit();
+	return value;
+}
+/** @type {ToMarkdownHandle} */
+function peekDelete() {
+	return "~";
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.js
+/**
+* @import {Code} from 'micromark-util-types'
+*/
+/**
+* Classify whether a code represents whitespace, punctuation, or something
+* else.
+*
+* Used for attention (emphasis, strong), whose sequences can open or close
+* based on the class of surrounding characters.
+*
+* > 👉 **Note**: eof (`null`) is seen as whitespace.
+*
+* @param {Code} code
+*   Code.
+* @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}
+*   Group.
+*/
+function classifyCharacter(code) {
+	if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) return 1;
+	if (unicodePunctuation(code)) return 2;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/mdast-util-gfm-table@2.0.0_supports-color@9.4.0/node_modules/mdast-util-gfm-table/lib/index.js
+/**
+* @typedef {import('mdast').InlineCode} InlineCode
+* @typedef {import('mdast').Table} Table
+* @typedef {import('mdast').TableCell} TableCell
+* @typedef {import('mdast').TableRow} TableRow
+*
+* @typedef {import('markdown-table').Options} MarkdownTableOptions
+*
+* @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+*
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+* @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+* @typedef {import('mdast-util-to-markdown').State} State
+* @typedef {import('mdast-util-to-markdown').Info} Info
+*/
+/**
+* @typedef Options
+*   Configuration.
+* @property {boolean | null | undefined} [tableCellPadding=true]
+*   Whether to add a space of padding between delimiters and cells (default:
+*   `true`).
+* @property {boolean | null | undefined} [tablePipeAlign=true]
+*   Whether to align the delimiters (default: `true`).
+* @property {MarkdownTableOptions['stringLength'] | null | undefined} [stringLength]
+*   Function to detect the length of table cell content, used when aligning
+*   the delimiters between cells (optional).
+*/
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM tables in
+* markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown` to enable GFM tables.
+*/
+function gfmTableFromMarkdown() {
+	return {
+		enter: {
+			table: enterTable,
+			tableData: enterCell,
+			tableHeader: enterCell,
+			tableRow: enterRow
+		},
+		exit: {
+			codeText: exitCodeText,
+			table: exitTable,
+			tableData: exit,
+			tableHeader: exit,
+			tableRow: exit
+		}
+	};
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterTable(token) {
+	const align = token._align;
+	this.enter({
+		type: "table",
+		align: align.map(function(d) {
+			return d === "none" ? null : d;
+		}),
+		children: []
+	}, token);
+	this.data.inTable = true;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitTable(token) {
+	this.exit(token);
+	this.data.inTable = void 0;
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterRow(token) {
+	this.enter({
+		type: "tableRow",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exit(token) {
+	this.exit(token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function enterCell(token) {
+	this.enter({
+		type: "tableCell",
+		children: []
+	}, token);
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitCodeText(token) {
+	let value = this.resume();
+	if (this.data.inTable) value = value.replace(/\\([\\|])/g, replace);
+	const node = this.stack[this.stack.length - 1];
+	node.type;
+	node.value = value;
+	this.exit(token);
+}
+/**
+* @param {string} $0
+* @param {string} $1
+* @returns {string}
+*/
+function replace($0, $1) {
+	return $1 === "|" ? $1 : $0;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/mdast-util-gfm-task-list-item@2.0.0_supports-color@9.4.0/node_modules/mdast-util-gfm-task-list-item/lib/index.js
+/**
+* @typedef {import('mdast').ListItem} ListItem
+* @typedef {import('mdast').Paragraph} Paragraph
+* @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+* @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+*/
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM task
+* list items in markdown.
+*
+* @returns {FromMarkdownExtension}
+*   Extension for `mdast-util-from-markdown` to enable GFM task list items.
+*/
+function gfmTaskListItemFromMarkdown() {
+	return { exit: {
+		taskListCheckValueChecked: exitCheck,
+		taskListCheckValueUnchecked: exitCheck,
+		paragraph: exitParagraphWithTaskListItem
+	} };
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitCheck(token) {
+	const node = this.stack[this.stack.length - 2];
+	node.type;
+	node.checked = token.type === "taskListCheckValueChecked";
+}
+/**
+* @this {CompileContext}
+* @type {FromMarkdownHandle}
+*/
+function exitParagraphWithTaskListItem(token) {
+	const parent = this.stack[this.stack.length - 2];
+	if (parent && parent.type === "listItem" && typeof parent.checked === "boolean") {
+		const node = this.stack[this.stack.length - 1];
+		node.type;
+		const head = node.children[0];
+		if (head && head.type === "text") {
+			const siblings = parent.children;
+			let index = -1;
+			/** @type {Paragraph | undefined} */
+			let firstParaghraph;
+			while (++index < siblings.length) {
+				const sibling = siblings[index];
+				if (sibling.type === "paragraph") {
+					firstParaghraph = sibling;
+					break;
+				}
+			}
+			if (firstParaghraph === node) {
+				head.value = head.value.slice(1);
+				if (head.value.length === 0) node.children.shift();
+				else if (node.position && head.position && typeof head.position.start.offset === "number") {
+					head.position.start.column++;
+					head.position.start.offset++;
+					node.position.start = Object.assign({}, head.position.start);
+				}
+			}
+		}
+	}
+	this.exit(token);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/mdast-util-gfm@3.1.0_supports-color@9.4.0/node_modules/mdast-util-gfm/lib/index.js
+/**
+* @import {Extension as FromMarkdownExtension} from 'mdast-util-from-markdown'
+* @import {Options} from 'mdast-util-gfm'
+* @import {Options as ToMarkdownExtension} from 'mdast-util-to-markdown'
+*/
+/**
+* Create an extension for `mdast-util-from-markdown` to enable GFM (autolink
+* literals, footnotes, strikethrough, tables, tasklists).
+*
+* @returns {Array<FromMarkdownExtension>}
+*   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,
+*   footnotes, strikethrough, tables, tasklists).
+*/
+function gfmFromMarkdown() {
+	return [
+		gfmAutolinkLiteralFromMarkdown(),
+		gfmFootnoteFromMarkdown(),
+		gfmStrikethroughFromMarkdown(),
+		gfmTableFromMarkdown(),
+		gfmTaskListItemFromMarkdown()
+	];
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.js
+/**
+* Like `Array#splice`, but smarter for giant arrays.
+*
+* `Array#splice` takes all items to be inserted as individual argument which
+* causes a stack overflow in V8 when trying to insert 100k items for instance.
+*
+* Otherwise, this does not return the removed items, and takes `items` as an
+* array instead of rest parameters.
+*
+* @template {unknown} T
+*   Item type.
+* @param {Array<T>} list
+*   List to operate on.
+* @param {number} start
+*   Index to remove/insert at (can be negative).
+* @param {number} remove
+*   Number of items to remove.
+* @param {Array<T>} items
+*   Items to inject into `list`.
+* @returns {undefined}
+*   Nothing.
+*/
+function splice(list, start, remove, items) {
+	const end = list.length;
+	let chunkStart = 0;
+	/** @type {Array<unknown>} */
+	let parameters;
+	if (start < 0) start = -start > end ? 0 : end + start;
+	else start = start > end ? end : start;
+	remove = remove > 0 ? remove : 0;
+	if (items.length < 1e4) {
+		parameters = Array.from(items);
+		parameters.unshift(start, remove);
+		list.splice(...parameters);
+	} else {
+		if (remove) list.splice(start, remove);
+		while (chunkStart < items.length) {
+			parameters = items.slice(chunkStart, chunkStart + 1e4);
+			parameters.unshift(start, 0);
+			list.splice(...parameters);
+			chunkStart += 1e4;
+			start += 1e4;
+		}
+	}
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.js
+/**
+* @import {
+*   Extension,
+*   Handles,
+*   HtmlExtension,
+*   NormalizedExtension
+* } from 'micromark-util-types'
+*/
+const hasOwnProperty = {}.hasOwnProperty;
+/**
+* Combine multiple syntax extensions into one.
+*
+* @param {ReadonlyArray<Extension>} extensions
+*   List of syntax extensions.
+* @returns {NormalizedExtension}
+*   A single combined extension.
+*/
+function combineExtensions(extensions) {
+	/** @type {NormalizedExtension} */
+	const all = {};
+	let index = -1;
+	while (++index < extensions.length) syntaxExtension(all, extensions[index]);
+	return all;
+}
+/**
+* Merge `extension` into `all`.
+*
+* @param {NormalizedExtension} all
+*   Extension to merge into.
+* @param {Extension} extension
+*   Extension to merge.
+* @returns {undefined}
+*   Nothing.
+*/
+function syntaxExtension(all, extension) {
+	/** @type {keyof Extension} */
+	let hook;
+	for (hook in extension) {
+		/** @type {Record<string, unknown>} */
+		const left = (hasOwnProperty.call(all, hook) ? all[hook] : void 0) || (all[hook] = {});
+		/** @type {Record<string, unknown> | undefined} */
+		const right = extension[hook];
+		/** @type {string} */
+		let code;
+		if (right) for (code in right) {
+			if (!hasOwnProperty.call(left, code)) left[code] = [];
+			const value = right[code];
+			constructs(left[code], Array.isArray(value) ? value : value ? [value] : []);
+		}
+	}
+}
+/**
+* Merge `list` into `existing` (both lists of constructs).
+* Mutates `existing`.
+*
+* @param {Array<unknown>} existing
+*   List of constructs to merge into.
+* @param {Array<unknown>} list
+*   List of constructs to merge.
+* @returns {undefined}
+*   Nothing.
+*/
+function constructs(existing, list) {
+	let index = -1;
+	/** @type {Array<unknown>} */
+	const before = [];
+	while (++index < list.length) (list[index].add === "after" ? existing : before).push(list[index]);
+	splice(existing, 0, 0, before);
+}
+//#endregion
+//#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'
+*/
+const wwwPrefix = {
+	tokenize: tokenizeWwwPrefix,
+	partial: true
+};
+const domain = {
+	tokenize: tokenizeDomain,
+	partial: true
+};
+const path = {
+	tokenize: tokenizePath,
+	partial: true
+};
+const trail = {
+	tokenize: tokenizeTrail,
+	partial: true
+};
+const emailDomainDotTrail = {
+	tokenize: tokenizeEmailDomainDotTrail,
+	partial: true
+};
+const wwwAutolink = {
+	name: "wwwAutolink",
+	tokenize: tokenizeWwwAutolink,
+	previous: previousWww
+};
+const protocolAutolink = {
+	name: "protocolAutolink",
+	tokenize: tokenizeProtocolAutolink,
+	previous: previousProtocol
+};
+const emailAutolink = {
+	name: "emailAutolink",
+	tokenize: tokenizeEmailAutolink,
+	previous: previousEmail
+};
+/** @type {ConstructRecord} */
+const 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} */
+let 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-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.js
+/**
+* @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'
+*/
+/**
+* Call all `resolveAll`s.
+*
+* @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs
+*   List of constructs, optionally with `resolveAll`s.
+* @param {Array<Event>} events
+*   List of events.
+* @param {TokenizeContext} context
+*   Context used by `tokenize`.
+* @returns {Array<Event>}
+*   Changed events.
+*/
+function resolveAll(constructs, events, context) {
+	/** @type {Array<Resolver>} */
+	const called = [];
+	let index = -1;
+	while (++index < constructs.length) {
+		const resolve = constructs[index].resolveAll;
+		if (resolve && !called.includes(resolve)) {
+			events = resolve(events, context);
+			called.push(resolve);
+		}
+	}
+	return events;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.js
+/**
+* @import {Effects, State, TokenType} from 'micromark-util-types'
+*/
+/**
+* Parse spaces and tabs.
+*
+* There is no `nok` parameter:
+*
+* *   spaces in markdown are often optional, in which case this factory can be
+*     used and `ok` will be switched to whether spaces were found or not
+* *   one line ending or space can be detected with `markdownSpace(code)` right
+*     before using `factorySpace`
+*
+* ###### Examples
+*
+* Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+* single space.
+*
+* ```markdown
+* ␉
+* ␠␠␠␠
+* ␉␠
+* ```
+*
+* @param {Effects} effects
+*   Context.
+* @param {State} ok
+*   State switched to when successful.
+* @param {TokenType} type
+*   Type (`' \t'`).
+* @param {number | undefined} [max=Infinity]
+*   Max (exclusive).
+* @returns {State}
+*   Start state.
+*/
+function factorySpace(effects, ok, type, max) {
+	const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+	let size = 0;
+	return start;
+	/** @type {State} */
+	function start(code) {
+		if (markdownSpace(code)) {
+			effects.enter(type);
+			return prefix(code);
+		}
+		return ok(code);
+	}
+	/** @type {State} */
+	function prefix(code) {
+		if (markdownSpace(code) && size++ < limit) {
+			effects.consume(code);
+			return prefix;
+		}
+		effects.exit(type);
+		return ok(code);
+	}
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const blankLine = {
+	partial: true,
+	tokenize: tokenizeBlankLine
+};
+/**
+* @this {TokenizeContext}
+*   Context.
+* @type {Tokenizer}
+*/
+function tokenizeBlankLine(effects, ok, nok) {
+	return start;
+	/**
+	* Start of blank line.
+	*
+	* > 👉 **Note**: `␠` represents a space character.
+	*
+	* ```markdown
+	* > | ␠␠␊
+	*     ^
+	* > | ␊
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		return markdownSpace(code) ? factorySpace(effects, after, "linePrefix")(code) : after(code);
+	}
+	/**
+	* At eof/eol, after optional whitespace.
+	*
+	* > 👉 **Note**: `␠` represents a space character.
+	*
+	* ```markdown
+	* > | ␠␠␊
+	*       ^
+	* > | ␊
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
+	}
+}
+//#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'
+*/
+const 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.2/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 = [];
+		/**
+		* Changes by index, so `add` does not scan `map` (quadratic on
+		* table-heavy documents).
+		*
+		* @type {Map<number, Change>}
+		*/
+		this.index = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Create an edit: a remove and/or add at a certain place.
+	*
+	* @param {number} index
+	*   Index at which to apply the edit.
+	* @param {number} remove
+	*   Count of items to remove at the index.
+	* @param {Array<Event>} add
+	*   Items to add at the index.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	add(index, remove, add) {
+		addImplementation(this, index, remove, add);
+	}
+	/**
+	* Done, change the events.
+	*
+	* @param {Array<Event>} events
+	*   List of events to apply the edits to.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	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;
+		this.index.clear();
+	}
+};
+/**
+* Create an edit.
+*
+* @param {EditMap} editMap
+*   Edit map to apply to.
+* @param {number} at
+*   Index at which to apply the edit.
+* @param {number} remove
+*   Count of items to remove at the index.
+* @param {Array<Event>} add
+*   Items to add at the index.
+* @returns {undefined}
+*   Nothing.
+*/
+function addImplementation(editMap, at, remove, add) {
+	/* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
+	if (remove === 0 && add.length === 0) return;
+	const existing = editMap.index.get(at);
+	if (existing) {
+		existing[1] += remove;
+		existing[2].push(...add);
+		return;
+	}
+	/** @type {Change} */
+	const change = [
+		at,
+		remove,
+		add
+	];
+	editMap.map.push(change);
+	editMap.index.set(at, change);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.2/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.2/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
+	} } };
+}
+/**
+* Tokenizer for GFM tables.
+*
+* @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];
+			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
+*   Edit map to apply to.
+* @param {Readonly<TokenizeContext>} context
+*   Tokenize context.
+* @param {Readonly<Range>} range
+*   Range of the cell within events.
+* @param {RowKind} rowKind
+*   Type of row.
+* @param {number | undefined} rowEnd
+*   Index of the end of the row, if known.
+* @param {Token | undefined} previousCell
+*   Previous cell token, if any.
+* @returns {Token | undefined}
+*   Current cell token after flushing, if any.
+*/
+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
+*   Edit map to apply to.
+* @param {Readonly<TokenizeContext>} context
+*   Tokenize context.
+* @param {number} index
+*   Index within the events where the table end should be inserted.
+* @param {Token} table
+*   Table token.
+* @param {Token | undefined} tableBody
+*   Table body token, if any.
+* @returns {undefined}
+*   Nothing.
+*/
+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);
+}
+/**
+* Get the point (start or end) for a given event in the list of events.
+*
+* @param {Readonly<Array<Event>>} events
+*   List of events.
+* @param {number} index
+*   Index of the event to get the point for.
+* @returns {Readonly<Point>}
+*   Start point for enter and end point for exit.
+*/
+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'
+*/
+const 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
+//#region ../../../node_modules/.pnpm/micromark-util-symbol@2.0.1/node_modules/micromark-util-symbol/lib/codes.js
+/**
+* Character codes.
+*
+* This module is compiled away!
+*
+* micromark works based on character codes.
+* This module contains constants for the ASCII block and the replacement
+* character.
+* A couple of them are handled in a special way, such as the line endings
+* (CR, LF, and CR+LF, commonly known as end-of-line: EOLs), the tab (horizontal
+* tab) and its expansion based on what column it’s at (virtual space),
+* and the end-of-file (eof) character.
+* As values are preprocessed before handling them, the actual characters LF,
+* CR, HT, and NUL (which is present as the replacement character), are
+* guaranteed to not exist.
+*
+* Unicode basic latin block.
+*/
+const codes = {
+	carriageReturn: -5,
+	lineFeed: -4,
+	carriageReturnLineFeed: -3,
+	horizontalTab: -2,
+	virtualSpace: -1,
+	eof: null,
+	nul: 0,
+	soh: 1,
+	stx: 2,
+	etx: 3,
+	eot: 4,
+	enq: 5,
+	ack: 6,
+	bel: 7,
+	bs: 8,
+	ht: 9,
+	lf: 10,
+	vt: 11,
+	ff: 12,
+	cr: 13,
+	so: 14,
+	si: 15,
+	dle: 16,
+	dc1: 17,
+	dc2: 18,
+	dc3: 19,
+	dc4: 20,
+	nak: 21,
+	syn: 22,
+	etb: 23,
+	can: 24,
+	em: 25,
+	sub: 26,
+	esc: 27,
+	fs: 28,
+	gs: 29,
+	rs: 30,
+	us: 31,
+	space: 32,
+	exclamationMark: 33,
+	quotationMark: 34,
+	numberSign: 35,
+	dollarSign: 36,
+	percentSign: 37,
+	ampersand: 38,
+	apostrophe: 39,
+	leftParenthesis: 40,
+	rightParenthesis: 41,
+	asterisk: 42,
+	plusSign: 43,
+	comma: 44,
+	dash: 45,
+	dot: 46,
+	slash: 47,
+	digit0: 48,
+	digit1: 49,
+	digit2: 50,
+	digit3: 51,
+	digit4: 52,
+	digit5: 53,
+	digit6: 54,
+	digit7: 55,
+	digit8: 56,
+	digit9: 57,
+	colon: 58,
+	semicolon: 59,
+	lessThan: 60,
+	equalsTo: 61,
+	greaterThan: 62,
+	questionMark: 63,
+	atSign: 64,
+	uppercaseA: 65,
+	uppercaseB: 66,
+	uppercaseC: 67,
+	uppercaseD: 68,
+	uppercaseE: 69,
+	uppercaseF: 70,
+	uppercaseG: 71,
+	uppercaseH: 72,
+	uppercaseI: 73,
+	uppercaseJ: 74,
+	uppercaseK: 75,
+	uppercaseL: 76,
+	uppercaseM: 77,
+	uppercaseN: 78,
+	uppercaseO: 79,
+	uppercaseP: 80,
+	uppercaseQ: 81,
+	uppercaseR: 82,
+	uppercaseS: 83,
+	uppercaseT: 84,
+	uppercaseU: 85,
+	uppercaseV: 86,
+	uppercaseW: 87,
+	uppercaseX: 88,
+	uppercaseY: 89,
+	uppercaseZ: 90,
+	leftSquareBracket: 91,
+	backslash: 92,
+	rightSquareBracket: 93,
+	caret: 94,
+	underscore: 95,
+	graveAccent: 96,
+	lowercaseA: 97,
+	lowercaseB: 98,
+	lowercaseC: 99,
+	lowercaseD: 100,
+	lowercaseE: 101,
+	lowercaseF: 102,
+	lowercaseG: 103,
+	lowercaseH: 104,
+	lowercaseI: 105,
+	lowercaseJ: 106,
+	lowercaseK: 107,
+	lowercaseL: 108,
+	lowercaseM: 109,
+	lowercaseN: 110,
+	lowercaseO: 111,
+	lowercaseP: 112,
+	lowercaseQ: 113,
+	lowercaseR: 114,
+	lowercaseS: 115,
+	lowercaseT: 116,
+	lowercaseU: 117,
+	lowercaseV: 118,
+	lowercaseW: 119,
+	lowercaseX: 120,
+	lowercaseY: 121,
+	lowercaseZ: 122,
+	leftCurlyBrace: 123,
+	verticalBar: 124,
+	rightCurlyBrace: 125,
+	tilde: 126,
+	del: 127,
+	byteOrderMarker: 65279,
+	replacementCharacter: 65533
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/micromark-util-symbol@2.0.1/node_modules/micromark-util-symbol/lib/types.js
+/**
+* This module is compiled away!
+*
+* Here is the list of all types of tokens exposed by micromark, with a short
+* explanation of what they include and where they are found.
+* In picking names, generally, the rule is to be as explicit as possible
+* instead of reusing names.
+* For example, there is a `definitionDestination` and a `resourceDestination`,
+* instead of one shared name.
+*/
+const types = {
+	data: "data",
+	whitespace: "whitespace",
+	lineEnding: "lineEnding",
+	lineEndingBlank: "lineEndingBlank",
+	linePrefix: "linePrefix",
+	lineSuffix: "lineSuffix",
+	atxHeading: "atxHeading",
+	atxHeadingSequence: "atxHeadingSequence",
+	atxHeadingText: "atxHeadingText",
+	autolink: "autolink",
+	autolinkEmail: "autolinkEmail",
+	autolinkMarker: "autolinkMarker",
+	autolinkProtocol: "autolinkProtocol",
+	characterEscape: "characterEscape",
+	characterEscapeValue: "characterEscapeValue",
+	characterReference: "characterReference",
+	characterReferenceMarker: "characterReferenceMarker",
+	characterReferenceMarkerNumeric: "characterReferenceMarkerNumeric",
+	characterReferenceMarkerHexadecimal: "characterReferenceMarkerHexadecimal",
+	characterReferenceValue: "characterReferenceValue",
+	codeFenced: "codeFenced",
+	codeFencedFence: "codeFencedFence",
+	codeFencedFenceSequence: "codeFencedFenceSequence",
+	codeFencedFenceInfo: "codeFencedFenceInfo",
+	codeFencedFenceMeta: "codeFencedFenceMeta",
+	codeFlowValue: "codeFlowValue",
+	codeIndented: "codeIndented",
+	codeText: "codeText",
+	codeTextData: "codeTextData",
+	codeTextPadding: "codeTextPadding",
+	codeTextSequence: "codeTextSequence",
+	content: "content",
+	definition: "definition",
+	definitionDestination: "definitionDestination",
+	definitionDestinationLiteral: "definitionDestinationLiteral",
+	definitionDestinationLiteralMarker: "definitionDestinationLiteralMarker",
+	definitionDestinationRaw: "definitionDestinationRaw",
+	definitionDestinationString: "definitionDestinationString",
+	definitionLabel: "definitionLabel",
+	definitionLabelMarker: "definitionLabelMarker",
+	definitionLabelString: "definitionLabelString",
+	definitionMarker: "definitionMarker",
+	definitionTitle: "definitionTitle",
+	definitionTitleMarker: "definitionTitleMarker",
+	definitionTitleString: "definitionTitleString",
+	emphasis: "emphasis",
+	emphasisSequence: "emphasisSequence",
+	emphasisText: "emphasisText",
+	escapeMarker: "escapeMarker",
+	hardBreakEscape: "hardBreakEscape",
+	hardBreakTrailing: "hardBreakTrailing",
+	htmlFlow: "htmlFlow",
+	htmlFlowData: "htmlFlowData",
+	htmlText: "htmlText",
+	htmlTextData: "htmlTextData",
+	image: "image",
+	label: "label",
+	labelText: "labelText",
+	labelLink: "labelLink",
+	labelImage: "labelImage",
+	labelMarker: "labelMarker",
+	labelImageMarker: "labelImageMarker",
+	labelEnd: "labelEnd",
+	link: "link",
+	paragraph: "paragraph",
+	reference: "reference",
+	referenceMarker: "referenceMarker",
+	referenceString: "referenceString",
+	resource: "resource",
+	resourceDestination: "resourceDestination",
+	resourceDestinationLiteral: "resourceDestinationLiteral",
+	resourceDestinationLiteralMarker: "resourceDestinationLiteralMarker",
+	resourceDestinationRaw: "resourceDestinationRaw",
+	resourceDestinationString: "resourceDestinationString",
+	resourceMarker: "resourceMarker",
+	resourceTitle: "resourceTitle",
+	resourceTitleMarker: "resourceTitleMarker",
+	resourceTitleString: "resourceTitleString",
+	setextHeading: "setextHeading",
+	setextHeadingText: "setextHeadingText",
+	setextHeadingLine: "setextHeadingLine",
+	setextHeadingLineSequence: "setextHeadingLineSequence",
+	strong: "strong",
+	strongSequence: "strongSequence",
+	strongText: "strongText",
+	thematicBreak: "thematicBreak",
+	thematicBreakSequence: "thematicBreakSequence",
+	blockQuote: "blockQuote",
+	blockQuotePrefix: "blockQuotePrefix",
+	blockQuoteMarker: "blockQuoteMarker",
+	blockQuotePrefixWhitespace: "blockQuotePrefixWhitespace",
+	listOrdered: "listOrdered",
+	listUnordered: "listUnordered",
+	listItemIndent: "listItemIndent",
+	listItemMarker: "listItemMarker",
+	listItemPrefix: "listItemPrefix",
+	listItemPrefixWhitespace: "listItemPrefixWhitespace",
+	listItemValue: "listItemValue",
+	chunkDocument: "chunkDocument",
+	chunkContent: "chunkContent",
+	chunkFlow: "chunkFlow",
+	chunkText: "chunkText",
+	chunkString: "chunkString"
+};
+//#endregion
+//#region ../../client/ui-primitives/src/reference.ts
+const DEFAULT_PROTOCOL = "file";
+const LINE_FRAGMENT = /^L(\d+)(?:C(\d+))?(?:-L(\d+))?$/u;
+const SCHEME = /^([A-Za-z][A-Za-z0-9+.-]*):/u;
+const BARE_PATH = /^([^:]+):(\d+)(?::(\d+))?$/u;
+const PATH_PUNCTUATION = [
+	codes.slash,
+	codes.dash,
+	codes.underscore,
+	codes.dot,
+	codes.plusSign,
+	codes.percentSign,
+	codes.atSign,
+	codes.tilde,
+	codes.equalsTo
+];
+const TRIGGERS = [
+	":",
+	"[",
+	"@"
+];
+function parseReference(value, title) {
+	const raw = value.trim();
+	if (raw === "") return void 0;
+	const matched = SCHEME.exec(raw);
+	const protocol = matched === null ? DEFAULT_PROTOCOL : matched[1].toLowerCase();
+	let rest = matched === null ? raw : raw.slice(matched[0].length);
+	if (matched !== null && /\s/u.test(rest)) return void 0;
+	const fragment = splitLineFragment(rest);
+	rest = fragment.head;
+	let origin;
+	if (rest.startsWith("//")) {
+		const end = authorityEnd(rest);
+		const authority = rest.slice(2, end);
+		if (authority === "") return void 0;
+		origin = `${protocol}://${authority}`;
+		rest = rest.slice(end).replace(/^\//u, "");
+	}
+	const decoded = protocol === DEFAULT_PROTOCOL ? decodeUri(rest) : rest;
+	if (decoded === void 0 || decoded === "" && origin === void 0) return void 0;
+	return {
+		protocol,
+		...origin === void 0 ? {} : { origin },
+		...decoded === "" ? {} : { path: decoded },
+		...title === void 0 || title === "" ? {} : { title },
+		...fragment.lines
+	};
+}
+function parseReferenceToken(value) {
+	return SCHEME.test(value) ? parseReference(value) : void 0;
+}
+function findReferences(text) {
+	const spans = [];
+	if (text === "" || !TRIGGERS.some((trigger) => text.includes(trigger))) return spans;
+	collectReferences(parseReferenceDocument(text), spans);
+	return spans;
+}
+function parseReferenceDocument(text) {
+	return fromMarkdown(text, {
+		extensions: [gfm(), referenceSyntax()],
+		mdastExtensions: [gfmFromMarkdown(), referenceFromMarkdown()]
+	});
+}
+function collectReferences(node, spans) {
+	const position = node.position;
+	if (node.type === "reference" && position !== void 0) {
+		const reference = referenceOfNode(node);
+		if (reference !== void 0) spans.push({
+			start: position.start.offset,
+			end: position.end.offset,
+			reference
+		});
+	}
+	for (const child of node.children ?? []) collectReferences(child, spans);
+}
+function referenceOfNode(node) {
+	const protocol = node.protocol;
+	if (protocol === void 0) return void 0;
+	return {
+		protocol,
+		...node.origin === void 0 ? {} : { origin: node.origin },
+		...node.path === void 0 ? {} : { path: node.path },
+		...node.title === void 0 ? {} : { title: node.title },
+		...node.lineStart === void 0 ? {} : { lineStart: node.lineStart },
+		...node.lineEnd === void 0 ? {} : { lineEnd: node.lineEnd },
+		...node.column === void 0 ? {} : { column: node.column }
+	};
+}
+const previousReference = function(code) {
+	return isBoundary(code);
+};
+const tokenizeReference = function(effects, ok, nok) {
+	const { events } = this;
+	let at = false;
+	let head = "";
+	return start;
+	function start(code) {
+		if (insideLabel(events)) return nok(code);
+		effects.enter("reference");
+		if (code === codes.atSign) {
+			at = true;
+			effects.consume(code);
+			return afterAt;
+		}
+		return headStart(code);
+	}
+	function afterAt(code) {
+		if (code === codes.quotationMark) {
+			effects.consume(code);
+			return quotedPath;
+		}
+		return asciiAlpha(code) ? headStart(code) : pathStart(code);
+	}
+	function quotedPath(code) {
+		if (code === null || markdownLineEnding(code)) return nok(code);
+		effects.consume(code);
+		return code === codes.quotationMark ? afterQuotedPath : quotedPath;
+	}
+	function afterQuotedPath(code) {
+		if (code !== codes.numberSign) return finish(code);
+		effects.consume(code);
+		return fragmentInside;
+	}
+	function fragmentInside(code) {
+		if (isPathCode(code) || code === codes.numberSign) {
+			effects.consume(code);
+			return fragmentInside;
+		}
+		return finish(code);
+	}
+	function headStart(code) {
+		if (!asciiAlpha(code)) return nok(code);
+		head = "";
+		return headInside(code);
+	}
+	function headInside(code) {
+		if (code === null || !asciiAlpha(code)) return afterHead(code);
+		head += String.fromCodePoint(code);
+		effects.consume(code);
+		return headInside;
+	}
+	function afterHead(code) {
+		if (code === codes.colon && isKnownScheme(head)) {
+			effects.consume(code);
+			return head.toLowerCase() === "skill" ? skillInside : fileInside;
+		}
+		return at ? pathInside(code) : nok(code);
+	}
+	function pathStart(code) {
+		if (!isPathCode(code) || code === codes.atSign) return nok(code);
+		effects.consume(code);
+		return pathInside;
+	}
+	function fileInside(code) {
+		if (!isFileCode(code)) return nok(code);
+		effects.consume(code);
+		return fileRest;
+	}
+	function fileRest(code) {
+		if (isFileCode(code)) {
+			effects.consume(code);
+			return fileRest;
+		}
+		return finish(code);
+	}
+	function skillInside(code) {
+		if (!isSkillCode(code)) return nok(code);
+		effects.consume(code);
+		return skillRest;
+	}
+	function skillRest(code) {
+		if (isSkillCode(code)) {
+			effects.consume(code);
+			return skillRest;
+		}
+		return finish(code);
+	}
+	function pathInside(code) {
+		if (isPathCode(code) || code === codes.numberSign) {
+			effects.consume(code);
+			return pathInside;
+		}
+		if (code !== codes.colon) return isBoundary(code) ? finish(code) : nok(code);
+		effects.consume(code);
+		return lineInside;
+	}
+	function lineInside(code) {
+		if (!asciiDigit(code)) return nok(code);
+		effects.consume(code);
+		return lineRest;
+	}
+	function lineRest(code) {
+		if (asciiDigit(code)) {
+			effects.consume(code);
+			return lineRest;
+		}
+		if (code !== codes.colon) return finish(code);
+		effects.consume(code);
+		return columnInside;
+	}
+	function columnInside(code) {
+		if (!asciiDigit(code)) return nok(code);
+		effects.consume(code);
+		return columnRest;
+	}
+	function columnRest(code) {
+		if (asciiDigit(code)) {
+			effects.consume(code);
+			return columnRest;
+		}
+		return finish(code);
+	}
+	function finish(code) {
+		if (!isBoundary(code)) return nok(code);
+		effects.exit("reference");
+		return ok(code);
+	}
+};
+const referenceConstruct = {
+	name: "reference",
+	previous: previousReference,
+	tokenize: tokenizeReference
+};
+const referenceSyntaxExtension = { text: {
+	[codes.atSign]: referenceConstruct,
+	[codes.lowercaseF]: referenceConstruct,
+	[codes.uppercaseF]: referenceConstruct,
+	[codes.lowercaseS]: referenceConstruct,
+	[codes.uppercaseS]: referenceConstruct
+} };
+function referenceSyntax() {
+	return referenceSyntaxExtension;
+}
+function insideLabel(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const token = events[index]?.[1];
+		if (token === void 0) continue;
+		if ((token.type === types.labelLink || token.type === types.labelImage) && token._balanced !== true) return true;
+	}
+	return false;
+}
+function isBoundary(code) {
+	return code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || unicodePunctuation(code);
+}
+function isPathCode(code) {
+	if (code === null || markdownLineEndingOrSpace(code)) return false;
+	if (!unicodePunctuation(code)) return true;
+	return PATH_PUNCTUATION.includes(code);
+}
+function isFileCode(code) {
+	return isPathCode(code) || code === codes.numberSign || code === codes.colon;
+}
+function isSkillCode(code) {
+	return asciiAlphanumeric(code) || code === codes.dash || code === codes.underscore || code === codes.dot;
+}
+function enterReference(token) {
+	this.enter({ type: "reference" }, token);
+}
+function exitReference(token) {
+	const node = this.stack[this.stack.length - 1];
+	const raw = this.sliceSerialize(token);
+	const reference = parseBareReference(raw);
+	if (node !== void 0) {
+		if (reference === void 0) {
+			node.type = "text";
+			node.value = raw;
+		} else Object.assign(node, reference);
+	}
+	this.exit(token);
+}
+const transformLinks = function(tree) {
+	convertLinks(tree);
+};
+function convertLinks(parent) {
+	const children = parent.children;
+	if (children === void 0) return;
+	for (let index = 0; index < children.length; index += 1) {
+		const child = children[index];
+		if (child === void 0) continue;
+		if (child.type === "link") {
+			const reference = parseReference(child.url ?? "", labelOf(child));
+			if (reference !== void 0) {
+				children[index] = referenceNodeOf(reference, child, children[index - 1]);
+				continue;
+			}
+		}
+		convertLinks(child);
+	}
+}
+function referenceNodeOf(reference, link, previous) {
+	const node = {
+		type: "reference",
+		...reference
+	};
+	const position = link.position;
+	if (position === void 0) return node;
+	node.position = startsAfterAt(previous, position.start) ? atStart(position) : position;
+	return node;
+}
+function startsAfterAt(previous, start) {
+	if (previous?.type !== "text" || previous.value?.endsWith("@") !== true) return false;
+	const position = previous.position;
+	if (position === void 0 || position.end.offset !== start.offset) return false;
+	return position.end.offset - position.start.offset === previous.value.length;
+}
+function atStart(position) {
+	return {
+		start: {
+			line: position.start.line,
+			column: position.start.column - 1,
+			offset: position.start.offset - 1
+		},
+		end: position.end
+	};
+}
+function labelOf(node) {
+	const label = textOf(node);
+	return label === "" ? void 0 : label;
+}
+function textOf(node) {
+	if (node.value !== void 0) return node.value;
+	let text = "";
+	for (const child of node.children ?? []) text += textOf(child);
+	return text;
+}
+function parseBareReference(raw) {
+	const body = raw.startsWith("@") ? raw.slice(1) : raw;
+	if (body === "") return void 0;
+	if (body.startsWith(QUOTED_PATH)) return parseQuotedReference(body);
+	const scheme = SCHEME.exec(body);
+	if (scheme !== null && isKnownScheme(scheme[1])) return parseReference(body);
+	const matched = BARE_PATH.exec(body);
+	const path = matched?.[1];
+	const line = matched?.[2];
+	if (path === void 0 || line === void 0) return parseReference(body);
+	const decoded = decodeUri(path);
+	if (decoded === void 0 || decoded === "") return void 0;
+	const column = matched?.[3];
+	return {
+		protocol: DEFAULT_PROTOCOL,
+		path: decoded,
+		lineStart: Number(line),
+		...column === void 0 ? {} : { column: Number(column) }
+	};
+}
+/** 引号 mention 的起手字符：`@"path with spaces"`。 */
+const QUOTED_PATH = "\"";
+function parseQuotedReference(body) {
+	const end = body.indexOf(QUOTED_PATH, 1);
+	if (end === -1) return void 0;
+	const path = body.slice(1, end);
+	if (path === "") return void 0;
+	const fragment = splitLineFragment(body.slice(end + 1));
+	if (fragment.head !== "") return void 0;
+	return {
+		protocol: DEFAULT_PROTOCOL,
+		path,
+		...fragment.lines
+	};
+}
+function referenceFromMarkdown() {
+	return {
+		enter: { reference: enterReference },
+		exit: { reference: exitReference },
+		transforms: [transformLinks]
+	};
+}
+function isKnownScheme(name) {
+	const protocol = name.toLowerCase();
+	return protocol === "file" || protocol === "skill";
+}
+function splitLineFragment(value) {
+	const hashAt = value.indexOf("#");
+	if (hashAt === -1) return {
+		head: value,
+		lines: {}
+	};
+	const matched = LINE_FRAGMENT.exec(value.slice(hashAt + 1));
+	if (matched === null) return {
+		head: value,
+		lines: {}
+	};
+	const lineStart = matched[1];
+	if (lineStart === void 0) return {
+		head: value,
+		lines: {}
+	};
+	const column = matched[2];
+	const lineEnd = matched[3];
+	return {
+		head: value.slice(0, hashAt),
+		lines: {
+			lineStart: Number(lineStart),
+			...column === void 0 ? {} : { column: Number(column) },
+			...lineEnd === void 0 ? {} : { lineEnd: Number(lineEnd) }
+		}
+	};
+}
+function authorityEnd(value) {
+	for (let index = 2; index < value.length; index += 1) {
+		const char = value[index];
+		if (char === "/" || char === "?" || char === "#") return index;
+	}
+	return value.length;
+}
+function decodeUri(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/links.ts
+const SKILL_PROTOCOL = "skill";
+const FILE_PROTOCOL = "file";
+const AT_PREFIX = "@";
+function walk(node, visit) {
+	visit(node);
+	for (const child of node.children ?? []) walk(child, visit);
+}
+function inlineCodeSkillNames(text) {
+	const names = [];
+	walk(fromMarkdown(text), (node) => {
+		if (node.type !== "inlineCode" || node.value === void 0) return;
+		const reference = parseReferenceToken(node.value);
+		if (reference?.protocol === SKILL_PROTOCOL && reference.path !== void 0) names.push(reference.path);
+	});
+	return names;
+}
+function forEachTextBlock(messages, visit) {
+	for (const message of messages) {
+		if (message.source.kind !== "user") continue;
+		for (const block of message.content) {
+			if (block.type !== "text") continue;
+			visit(block.text);
+		}
+	}
+}
+function skillNamesIn(messages) {
+	const names = [];
+	const push = (name) => {
+		if (name === void 0 || name === "" || names.includes(name)) return;
+		names.push(name);
+	};
+	forEachTextBlock(messages, (text) => {
+		for (const span of findReferences(text)) {
+			if (span.reference.protocol !== SKILL_PROTOCOL) continue;
+			push(span.reference.path);
+		}
+		for (const name of inlineCodeSkillNames(text)) push(name);
+	});
+	return names;
+}
+function fileReferencesIn(messages) {
+	const references = [];
+	forEachTextBlock(messages, (text) => {
+		for (const span of findReferences(text)) {
+			const reference = span.reference;
+			if (text[span.start] !== AT_PREFIX || reference.protocol !== FILE_PROTOCOL) continue;
+			const path = reference.path;
+			if (path === void 0 || path === "") continue;
+			const lineStart = reference.lineStart;
+			const next = {
+				path,
+				...lineStart === void 0 ? {} : { lineStart },
+				...lineStart === void 0 || reference.lineEnd === void 0 ? {} : { lineEnd: reference.lineEnd }
+			};
+			if (references.some((known) => sameWindow(known, next))) continue;
+			references.push(next);
+		}
+	});
+	return references;
+}
+function sameWindow(left, right) {
+	return left.path === right.path && left.lineStart === right.lineStart && left.lineEnd === right.lineEnd;
+}
+//#endregion
+//#region src/index.ts
+const name = "reference";
+const inject = ["skills"];
+/**
+* 内容之外的一条说明（见层级设计「内容之外的说明」）：不说来源，模型会再 read 一遍同一段内容。
+* 与内容同处一条消息，所以同一步有多个引用时它也只说一次。
+*/
+const NOTE = [
+	"<system-reminder>",
+	"这些文件内容是按你消息里的 @ 引用刚读取的，直接用它即可，不必再 read 一遍。",
+	"</system-reminder>"
+].join("\n");
+function apply(ctx) {
+	ctx.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
+		const decision = await next();
+		if (decision.kind === "reject") return decision;
+		const tools = (() => {
+			try {
+				return ctx.get("tools");
+			} catch {
+				return;
+			}
+		})();
+		const hasTool = (name) => tools === void 0 || tools.get(name, agent) !== void 0;
+		const hasRead = hasTool("read");
+		const names = hasTool("skill") ? skillNamesIn(messages) : [];
+		const files = hasRead ? fileReferencesIn(messages) : [];
+		if (names.length === 0 && files.length === 0) return decision;
+		signal.throwIfAborted();
+		const cwd = agent.session.header.cwd;
+		const injections = [];
+		for (const name of names) {
+			const skill = await ctx.skills.get(name, {
+				cwd,
+				signal,
+				scope: agent
+			});
+			signal.throwIfAborted();
+			if (skill === void 0 || !isUserInvocable(skill)) continue;
+			const source = {
+				kind: "skill-invocation",
+				name,
+				form: "instructions"
+			};
+			injections.push(createUserMessage({
+				content: [{
+					type: "text",
+					text: renderSkillContent(skill)
+				}],
+				source
+			}));
+		}
+		const fs = ctx.get("fs");
+		const read = [];
+		const envelopes = [];
+		for (const reference of files) {
+			const envelope = fs === void 0 ? void 0 : await readFileContent(fs, reference, {
+				cwd,
+				signal
+			});
+			signal.throwIfAborted();
+			if (envelope === void 0) continue;
+			read.push(reference);
+			envelopes.push({
+				type: "text",
+				text: envelope
+			});
+		}
+		if (read.length > 0) injections.push(createUserMessage({
+			content: [{
+				type: "text",
+				text: NOTE
+			}, ...envelopes],
+			source: {
+				kind: "file-reference",
+				references: read
+			}
+		}));
+		if (injections.length === 0) return decision;
+		return {
+			...decision,
+			messages: [...decision.messages, ...injections]
+		};
+	});
+}
+//#endregion
+export { apply, inject, name };