@morlay/dsh-reference 0.0.5 → 0.0.7

package/dist/index.mjs

@@ -1,6 +1,10 @@
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { isUserInvocable, renderSkillContent } from "@deepseek-ai/dsh-skill";
 import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { asciiAlpha, asciiAlphanumeric, asciiDigit, markdownLineEnding, markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from "micromark-util-character";
+import { gfm } from "micromark-extension-gfm";
+import { codes, types } from "micromark-util-symbol";
 //#region src/file-content.ts
 const READ_LIMIT = 2e3;
 const READ_MAX_LINE_LENGTH = 2e3;
@@ -92,4322 +96,7 @@ ${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.1_supports-color@9.4.0/node_modules/mdast-util-gfm-strikethrough/lib/index.js
-handleDelete.attention = attentionDelete;
-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 }
-	};
-}
-/**
-* Enter strikethrough.
-*
-* @this {CompileContext}
-* @type {FromMarkdownHandle}
-*/
-function enterStrikethrough(token) {
-	this.enter({
-		type: "delete",
-		children: [],
-		position: void 0
-	}, token);
-}
-/**
-* Exit strikethrough.
-*
-* @this {CompileContext}
-* @type {FromMarkdownHandle}
-*/
-function exitStrikethrough(token) {
-	this.exit(token);
-}
-/**
-* Serialize a delete node.
-*
-* @type {ToMarkdownHandle}
-* @param {Delete} node
-*   Node to serialize.
-*/
-function handleDelete(node, _, state, info) {
-	const tracker = state.createTracker(info);
-	const sequence = state.stack.includes("strikethrough") ? "~" : "~~";
-	const exit = state.enter("strikethrough");
-	let value = tracker.move(sequence);
-	value += state.containerPhrasing(node, {
-		...tracker.current(),
-		before: value,
-		after: "~"
-	});
-	value += tracker.move(sequence);
-	exit();
-	return value;
-}
-/**
-* Serialize a delete node as attention.
-*
-* @type {Attention}
-*/
-function attentionDelete() {
-	return {
-		construct: "strikethrough",
-		markers: ["~"],
-		sizes: [2, 1]
-	};
-}
-/**
-* Peek the first character of a delete node.
-*
-* @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.1.0/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 of the whole whitespace.
-* @param {number | undefined} [max=Infinity]
-*   Max (exclusive).
-* @returns {State}
-*   Start state.
-*/
-function factorySpace(effects, ok, type, max) {
-	const limit = max ? max - 1 : 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.4/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
+//#region ../../client/dsh-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;