mdat 1.2.0 → 1.2.2

package/dist/index.js

@@ -6706,6 +6706,14 @@ function push(list$3, items) {
 
 //#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.
@@ -7047,6 +7055,9 @@ function regexCheck(regex$1) {
 //#endregion
 //#region node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.js
 /**
+* @import {Effects, State, TokenType} from 'micromark-util-types'
+*/
+/**
 * Parse spaces and tabs.
 *
 * There is no `nok` parameter:
@@ -7103,6 +7114,15 @@ function factorySpace(effects, ok$2, type, max) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/content.js
+/**
+* @import {
+*   InitialConstruct,
+*   Initializer,
+*   State,
+*   TokenizeContext,
+*   Token
+* } from 'micromark-util-types'
+*/
 /** @type {InitialConstruct} */
 const content = { tokenize: initializeContent };
 /**
@@ -7162,6 +7182,23 @@ function initializeContent(effects) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/document.js
+/**
+* @import {
+*   Construct,
+*   ContainerState,
+*   InitialConstruct,
+*   Initializer,
+*   Point,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
+/**
+* @typedef {[Construct, ContainerState]} StackItem
+*   Construct and its state.
+*/
 /** @type {InitialConstruct} */
 const document = { tokenize: initializeDocument };
 /** @type {Construct} */
@@ -7363,6 +7400,9 @@ function tokenizeContainer(effects, ok$2, nok) {
 //#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.
 *
@@ -7414,6 +7454,19 @@ function resolveAll(constructs$1, events, context) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/attention.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   Event,
+*   Point,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const attention = {
 	name: "attention",
@@ -7622,6 +7675,14 @@ function movePoint(point$2, offset) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/autolink.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const autolink = {
 	name: "autolink",
@@ -7826,6 +7887,14 @@ function tokenizeAutolink(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const blankLine = {
 	partial: true,
@@ -7876,6 +7945,15 @@ function tokenizeBlankLine(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.js
+/**
+* @import {
+*   Construct,
+*   Exiter,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const blockQuote = {
 	continuation: { tokenize: tokenizeBlockQuoteContinuation },
@@ -7995,6 +8073,14 @@ function exit$1(effects) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-escape.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const characterEscape = {
 	name: "characterEscape",
@@ -8048,6 +8134,15 @@ function tokenizeCharacterEscape(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const characterReference = {
 	name: "characterReference",
@@ -8178,6 +8273,15 @@ function tokenizeCharacterReference(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-fenced.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const nonLazyContinuation = {
 	partial: true,
@@ -8585,6 +8689,14 @@ function tokenizeNonLazyContinuation(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-indented.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const codeIndented = {
 	name: "codeIndented",
@@ -8722,6 +8834,17 @@ function tokenizeFurtherStart(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.js
+/**
+* @import {
+*   Construct,
+*   Previous,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const codeText = {
 	name: "codeText",
@@ -9129,6 +9252,9 @@ function chunkedPush(list$3, right) {
 //#endregion
 //#region node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.js
 /**
+* @import {Chunk, Event, Token} from 'micromark-util-types'
+*/
+/**
 * Tokenize subcontent.
 *
 * @param {Array<Event>} eventsArray
@@ -9282,6 +9408,16 @@ function subcontent(events, eventIndex) {
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.js
 /**
+* @import {
+*   Construct,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
+/**
 * No name because it must not be turned off.
 * @type {Construct}
 */
@@ -9406,6 +9542,9 @@ function tokenizeContinuation(effects, ok$2, nok) {
 //#endregion
 //#region node_modules/.pnpm/micromark-factory-destination@2.0.1/node_modules/micromark-factory-destination/index.js
 /**
+* @import {Effects, State, TokenType} from 'micromark-util-types'
+*/
+/**
 * Parse destinations.
 *
 * ###### Examples
@@ -9588,6 +9727,14 @@ function factoryDestination(effects, ok$2, nok, type, literalType$1, literalMark
 //#endregion
 //#region node_modules/.pnpm/micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.js
 /**
+* @import {
+*   Effects,
+*   State,
+*   TokenizeContext,
+*   TokenType
+* } from 'micromark-util-types'
+*/
+/**
 * Parse labels.
 *
 * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.
@@ -9713,6 +9860,14 @@ function factoryLabel(effects, ok$2, nok, type, markerType, stringType$1) {
 //#endregion
 //#region node_modules/.pnpm/micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.js
 /**
+* @import {
+*   Code,
+*   Effects,
+*   State,
+*   TokenType
+* } from 'micromark-util-types'
+*/
+/**
 * Parse titles.
 *
 * ###### Examples
@@ -9851,6 +10006,9 @@ function factoryTitle(effects, ok$2, nok, type, markerType, stringType$1) {
 //#endregion
 //#region node_modules/.pnpm/micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.js
 /**
+* @import {Effects, State} from 'micromark-util-types'
+*/
+/**
 * Parse spaces and tabs.
 *
 * There is no `nok` parameter:
@@ -9888,6 +10046,14 @@ function factoryWhitespace(effects, ok$2) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const definition$1 = {
 	name: "definition",
@@ -10096,6 +10262,14 @@ function tokenizeTitleBefore(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const hardBreakEscape = {
 	name: "hardBreakEscape",
@@ -10146,6 +10320,16 @@ function tokenizeHardBreakEscape(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/heading-atx.js
+/**
+* @import {
+*   Construct,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const headingAtx = {
 	name: "headingAtx",
@@ -10422,6 +10606,16 @@ const htmlRawNames = [
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-flow.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const htmlFlow = {
 	concrete: true,
@@ -11186,6 +11380,15 @@ function tokenizeBlankLineBefore(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-text.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const htmlText = {
 	name: "htmlText",
@@ -11792,6 +11995,17 @@ function tokenizeHtmlText(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-end.js
+/**
+* @import {
+*   Construct,
+*   Event,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer,
+*   Token
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const labelEnd = {
 	name: "labelEnd",
@@ -12252,6 +12466,14 @@ function tokenizeReferenceCollapsed(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-image.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const labelStartImage = {
 	name: "labelStartImage",
@@ -12338,6 +12560,14 @@ function tokenizeLabelStartImage(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-link.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const labelStartLink = {
 	name: "labelStartLink",
@@ -12379,6 +12609,14 @@ function tokenizeLabelStartLink(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/line-ending.js
+/**
+* @import {
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const lineEnding = {
 	name: "lineEnding",
@@ -12402,6 +12640,15 @@ function tokenizeLineEnding(effects, ok$2) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/thematic-break.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const thematicBreak$1 = {
 	name: "thematicBreak",
@@ -12489,6 +12736,16 @@ function tokenizeThematicBreak(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/list.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   Exiter,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const list$2 = {
 	continuation: { tokenize: tokenizeListContinuation },
@@ -12652,6 +12909,16 @@ function tokenizeListItemPrefixWhitespace(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/setext-underline.js
+/**
+* @import {
+*   Code,
+*   Construct,
+*   Resolver,
+*   State,
+*   TokenizeContext,
+*   Tokenizer
+* } from 'micromark-util-types'
+*/
 /** @type {Construct} */
 const setextUnderline = {
 	name: "setextUnderline",
@@ -12795,6 +13062,14 @@ function tokenizeSetextUnderline(effects, ok$2, nok) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/flow.js
+/**
+* @import {
+*   InitialConstruct,
+*   Initializer,
+*   State,
+*   TokenizeContext
+* } from 'micromark-util-types'
+*/
 /** @type {InitialConstruct} */
 const flow = { tokenize: initializeFlow };
 /**
@@ -13013,6 +13288,9 @@ function resolveAllLineSuffixes(events, context) {
 
 //#endregion
 //#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.js
+/**
+* @import {Extension} from 'micromark-util-types'
+*/
 var constructs_exports = /* @__PURE__ */ __export({
 	attentionMarkers: () => attentionMarkers,
 	contentInitial: () => contentInitial,
@@ -13090,6 +13368,43 @@ const disable = { null: [] };
 //#endregion
 //#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.js
 /**
+* @import {
+*   Chunk,
+*   Code,
+*   ConstructRecord,
+*   Construct,
+*   Effects,
+*   InitialConstruct,
+*   ParseContext,
+*   Point,
+*   State,
+*   TokenizeContext,
+*   Token
+* } from 'micromark-util-types'
+*/
+/**
+* @callback Restore
+*   Restore the state.
+* @returns {undefined}
+*   Nothing.
+*
+* @typedef Info
+*   Info.
+* @property {Restore} restore
+*   Restore.
+* @property {number} from
+*   From.
+*
+* @callback ReturnHandle
+*   Handle a successful run.
+* @param {Construct} construct
+*   Construct.
+* @param {Info} info
+*   Info.
+* @returns {undefined}
+*   Nothing.
+*/
+/**
 * Create a tokenizer.
 * Tokenizers deal with one type of data (e.g., containers, flow, text).
 * The parser is the object dealing with it all.
@@ -13523,6 +13838,15 @@ function serializeChunks(chunks, expandTabs) {
 //#endregion
 //#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/parse.js
 /**
+* @import {
+*   Create,
+*   FullNormalizedExtension,
+*   InitialConstruct,
+*   ParseContext,
+*   ParseOptions
+* } from 'micromark-util-types'
+*/
+/**
 * @param {ParseOptions | null | undefined} [options]
 *   Configuration (optional).
 * @returns {ParseContext}
@@ -13559,6 +13883,9 @@ function parse(options) {
 //#endregion
 //#region node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/postprocess.js
 /**
+* @import {Event} from 'micromark-util-types'
+*/
+/**
 * @param {Array<Event>} events
 *   Events.
 * @returns {Array<Event>}
@@ -13776,6 +14103,46 @@ function index(value) {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-from-markdown@2.0.2/node_modules/mdast-util-from-markdown/lib/index.js
+/**
+* @import {
+*   Break,
+*   Blockquote,
+*   Code,
+*   Definition,
+*   Emphasis,
+*   Heading,
+*   Html,
+*   Image,
+*   InlineCode,
+*   Link,
+*   ListItem,
+*   List,
+*   Nodes,
+*   Paragraph,
+*   PhrasingContent,
+*   ReferenceType,
+*   Root,
+*   Strong,
+*   Text,
+*   ThematicBreak
+* } from 'mdast'
+* @import {
+*   Encoding,
+*   Event,
+*   Token,
+*   Value
+* } from 'micromark-util-types'
+* @import {Point} from 'unist'
+* @import {
+*   CompileContext,
+*   CompileData,
+*   Config,
+*   Extension,
+*   Handle,
+*   OnEnterError,
+*   Options
+* } from './types.js'
+*/
 const own$4 = {}.hasOwnProperty;
 /**
 * Turn markdown into a syntax tree.
@@ -14704,6 +15071,15 @@ function defaultOnError(left, right) {
 //#endregion
 //#region node_modules/.pnpm/remark-parse@11.0.0/node_modules/remark-parse/lib/index.js
 /**
+* @typedef {import('mdast').Root} Root
+* @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions
+* @typedef {import('unified').Parser<Root>} Parser
+* @typedef {import('unified').Processor<Root>} Processor
+*/
+/**
+* @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options
+*/
+/**
 * Aadd support for parsing from markdown.
 *
 * @param {Readonly<Options> | null | undefined} [options]
@@ -14939,6 +15315,10 @@ function listInScope(stack, list$3, none) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/break.js
 /**
+* @import {Break, Parents} from 'mdast'
+* @import {Info, State} from 'mdast-util-to-markdown'
+*/
+/**
 * @param {Break} _
 * @param {Parents | undefined} _1
 * @param {State} state
@@ -15013,6 +15393,10 @@ function checkFence(state) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/code.js
 /**
+* @import {Info, Map, State} from 'mdast-util-to-markdown'
+* @import {Code, Parents} from 'mdast'
+*/
+/**
 * @param {Code} node
 * @param {Parents | undefined} _
 * @param {State} state
@@ -15083,6 +15467,10 @@ function checkQuote(state) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/definition.js
 /**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Definition, Parents} from 'mdast'
+*/
+/**
 * @param {Definition} node
 * @param {Parents | undefined} _
 * @param {State} state
@@ -15168,6 +15556,9 @@ function encodeCharacterReference(code$2) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/encode-info.js
 /**
+* @import {EncodeSides} from '../types.js'
+*/
+/**
 * Check whether to encode (as a character reference) the characters
 * surrounding an attention run.
 *
@@ -15237,6 +15628,10 @@ function encodeInfo(outside, inside, marker) {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Emphasis, Parents} from 'mdast'
+*/
 emphasis.peek = emphasisPeek;
 /**
 * @param {Emphasis} node
@@ -15401,6 +15796,211 @@ function color(d) {
 
 //#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 = [];
 /**
@@ -15531,6 +16131,216 @@ function toResult(value) {
 //#endregion
 //#region node_modules/.pnpm/unist-util-visit@5.0.0/node_modules/unist-util-visit/lib/index.js
 /**
+* @typedef {import('unist').Node} UnistNode
+* @typedef {import('unist').Parent} UnistParent
+* @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+*/
+/**
+* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+*   Test from `unist-util-is`.
+*
+*   Note: we have remove and add `undefined`, because otherwise when generating
+*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+*   which doesn’t work when publishing on npm.
+*/
+/**
+* @typedef {(
+*   Fn extends (value: any) => value is infer Thing
+*   ? Thing
+*   : Fallback
+* )} Predicate
+*   Get the value of a type guard `Fn`.
+* @template Fn
+*   Value; typically function that is a type guard (such as `(x): x is Y`).
+* @template Fallback
+*   Value to yield if `Fn` is not a type guard.
+*/
+/**
+* @typedef {(
+*   Check extends null | undefined // No test.
+*   ? Value
+*   : Value extends {type: Check} // String (type) test.
+*   ? Value
+*   : Value extends Check // Partial test.
+*   ? Value
+*   : Check extends Function // Function test.
+*   ? Predicate<Check, Value> extends Value
+*     ? Predicate<Check, Value>
+*     : never
+*   : never // Some other test?
+* )} MatchesOne
+*   Check whether a node matches a primitive check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test, but not arrays.
+*/
+/**
+* @typedef {(
+*   Check extends Array<any>
+*   ? MatchesOne<Value, Check[keyof Check]>
+*   : MatchesOne<Value, Check>
+* )} Matches
+*   Check whether a node matches a check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test.
+*/
+/**
+* @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
+*   Number; capped reasonably.
+*/
+/**
+* @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
+*   Increment a number in the type system.
+* @template {Uint} [I=0]
+*   Index.
+*/
+/**
+* @typedef {(
+*   Node extends UnistParent
+*   ? Node extends {children: Array<infer Children>}
+*     ? Child extends Children ? Node : never
+*     : never
+*   : never
+* )} InternalParent
+*   Collect nodes that can be parents of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent
+*   Collect nodes in `Tree` that can be parents of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Depth extends Max
+*   ? never
+*   :
+*     | InternalParent<Node, Child>
+*     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
+* )} InternalAncestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {(
+*   Tree extends UnistParent
+*     ? Depth extends Max
+*       ? Tree
+*       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
+*     : Tree
+* )} InclusiveDescendant
+*   Collect all (inclusive) descendants of `Tree`.
+*
+*   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
+*   > recurse without actually running into an infinite loop, which the
+*   > previous version did.
+*   >
+*   > Practically, a max of `2` is typically enough assuming a `Root` is
+*   > passed, but it doesn’t improve performance.
+*   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
+*   > Using up to `10` doesn’t hurt or help either.
+* @template {UnistNode} Tree
+*   Tree type.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @callback Visitor
+*   Handle a node (matching `test`, if given).
+*
+*   Visitors are free to transform `node`.
+*   They can also transform `parent`.
+*
+*   Replacing `node` itself, if `SKIP` is not returned, still causes its
+*   descendants to be walked (which is a bug).
+*
+*   When adding or removing previous siblings of `node` (or next siblings, in
+*   case of reverse), the `Visitor` should return a new `Index` to specify the
+*   sibling to traverse after `node` is traversed.
+*   Adding or removing next siblings of `node` (or previous siblings, in case
+*   of reverse) is handled as expected without needing to return a new `Index`.
+*
+*   Removing the children property of `parent` still results in them being
+*   traversed.
+* @param {Visited} node
+*   Found node.
+* @param {Visited extends UnistNode ? number | undefined : never} index
+*   Index of `node` in `parent`.
+* @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+*   Parent of `node`.
+* @returns {VisitorResult}
+*   What to do next.
+*
+*   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
+*   An `Action` is treated as a tuple of `[Action]`.
+*
+*   Passing a tuple back only makes sense if the `Action` is `SKIP`.
+*   When the `Action` is `EXIT`, that action can be returned.
+*   When the `Action` is `CONTINUE`, `Index` can be returned.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [Ancestor=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
+*   Build a typed `Visitor` function from a node and all possible parents.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Visited
+*   Node type.
+* @template {UnistParent} Ancestor
+*   Parent type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromMatch<
+*     Matches<Descendant, Check>,
+*     Extract<Descendant, UnistParent>
+*   >
+* )} BuildVisitorFromDescendants
+*   Build a typed `Visitor` function from a list of descendants and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Descendant
+*   Node type.
+* @template {Test} Check
+*   Test type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromDescendants<
+*     InclusiveDescendant<Tree>,
+*     Check
+*   >
+* )} BuildVisitor
+*   Build a typed `Visitor` function from a tree and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} [Tree=UnistNode]
+*   Node type.
+* @template {Test} [Check=Test]
+*   Test type.
+*/
+/**
 * Visit nodes.
 *
 * This algorithm performs *depth-first* *tree traversal* in *preorder*
@@ -15608,6 +16418,10 @@ function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
 /**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Heading} from 'mdast'
+*/
+/**
 * @param {Heading} node
 * @param {State} state
 * @returns {boolean}
@@ -15626,6 +16440,10 @@ function formatHeadingAsSetext(node$1, state) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/heading.js
 /**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Heading, Parents} from 'mdast'
+*/
+/**
 * @param {Heading} node
 * @param {Parents | undefined} _
 * @param {State} state
@@ -15686,6 +16504,10 @@ function htmlPeek() {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/image.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Image, Parents} from 'mdast'
+*/
 image.peek = imagePeek;
 /**
 * @param {Image} node
@@ -15841,6 +16663,10 @@ function inlineCodePeek() {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js
 /**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Link} from 'mdast'
+*/
+/**
 * @param {Link} node
 * @param {State} state
 * @returns {boolean}
@@ -15852,6 +16678,11 @@ function formatLinkAsAutolink(node$1, state) {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/link.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Link, Parents} from 'mdast'
+* @import {Exit} from '../types.js'
+*/
 link.peek = linkPeek;
 /**
 * @param {Link} node
@@ -16004,6 +16835,9 @@ function checkBullet(state) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js
 /**
+* @import {Options, State} from 'mdast-util-to-markdown'
+*/
+/**
 * @param {State} state
 * @returns {Exclude<Options['bullet'], null | undefined>}
 */
@@ -16049,6 +16883,10 @@ function checkRule(state) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list.js
 /**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {List, Parents} from 'mdast'
+*/
+/**
 * @param {List} node
 * @param {Parents | undefined} parent
 * @param {State} state
@@ -16104,6 +16942,10 @@ function checkListItemIndent(state) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/list-item.js
 /**
+* @import {Info, Map, State} from 'mdast-util-to-markdown'
+* @import {ListItem, Parents} from 'mdast'
+*/
+/**
 * @param {ListItem} node
 * @param {Parents | undefined} parent
 * @param {State} state
@@ -16155,6 +16997,10 @@ function paragraph(node$1, _, state, info) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-phrasing@4.1.0/node_modules/mdast-util-phrasing/lib/index.js
 /**
+* @typedef {import('mdast').Html} Html
+* @typedef {import('mdast').PhrasingContent} PhrasingContent
+*/
+/**
 * Check if the given value is *phrasing content*.
 *
 * > 👉 **Note**: Excludes `html`, which can be both phrasing or flow.
@@ -16186,6 +17032,10 @@ const phrasing = convert([
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/root.js
 /**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Root} from 'mdast'
+*/
+/**
 * @param {Root} node
 * @param {Parents | undefined} _
 * @param {State} state
@@ -16215,6 +17065,10 @@ function checkStrong(state) {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/strong.js
+/**
+* @import {Info, State} from 'mdast-util-to-markdown'
+* @import {Parents, Strong} from 'mdast'
+*/
 strong.peek = strongPeek;
 /**
 * @param {Strong} node
@@ -16292,6 +17146,10 @@ function checkRuleRepetition(state) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
 /**
+* @import {State} from 'mdast-util-to-markdown'
+* @import {Parents, ThematicBreak} from 'mdast'
+*/
+/**
 * @param {ThematicBreak} _
 * @param {Parents | undefined} _1
 * @param {State} state
@@ -16332,6 +17190,9 @@ const handle = {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/join.js
+/**
+* @import {Join} from 'mdast-util-to-markdown'
+*/
 /** @type {Array<Join>} */
 const join = [joinDefaults];
 /** @type {Join} */
@@ -16569,6 +17430,9 @@ const unsafe = [
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/association.js
 /**
+* @import {AssociationId} from '../types.js'
+*/
+/**
 * Get an identifier from an association to match it to others.
 *
 * Associations are nodes that match to something else through an ID:
@@ -16612,6 +17476,10 @@ function compilePattern(pattern) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
 /**
+* @import {Handle, Info, State} from 'mdast-util-to-markdown'
+* @import {PhrasingParents} from '../types.js'
+*/
+/**
 * Serialize the children of a parent that contains phrasing children.
 *
 * These children will be joined flush together.
@@ -16770,6 +17638,9 @@ function indentLines(value, map$3) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/util/safe.js
 /**
+* @import {SafeConfig, State} from 'mdast-util-to-markdown'
+*/
+/**
 * Make a string safe for embedding in markdown constructs.
 *
 * In markdown, almost all punctuation characters can, in certain cases,
@@ -16940,6 +17811,11 @@ function track(config$1) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/index.js
 /**
+* @import {Info, Join, Options, SafeConfig, State} from 'mdast-util-to-markdown'
+* @import {Nodes} from 'mdast'
+* @import {Enter, FlowParents, PhrasingParents, TrackFields} from './types.js'
+*/
+/**
 * Turn an mdast syntax tree into markdown.
 *
 * @param {Nodes} tree
@@ -17085,6 +17961,15 @@ function safeBound(value, config$1) {
 //#endregion
 //#region node_modules/.pnpm/remark-stringify@11.0.0/node_modules/remark-stringify/lib/index.js
 /**
+* @typedef {import('mdast').Root} Root
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownOptions
+* @typedef {import('unified').Compiler<Root, string>} Compiler
+* @typedef {import('unified').Processor<undefined, undefined, undefined, Root, string>} Processor
+*/
+/**
+* @typedef {Omit<ToMarkdownOptions, 'extensions'>} Options
+*/
+/**
 * Add support for serializing to markdown.
 *
 * @param {Readonly<Options> | null | undefined} [options]
@@ -17379,6 +18264,337 @@ const CallableInstance = (function(property) {
 
 //#endregion
 //#region node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/index.js
+/**
+* @typedef {import('trough').Pipeline} Pipeline
+*
+* @typedef {import('unist').Node} Node
+*
+* @typedef {import('vfile').Compatible} Compatible
+* @typedef {import('vfile').Value} Value
+*
+* @typedef {import('../index.js').CompileResultMap} CompileResultMap
+* @typedef {import('../index.js').Data} Data
+* @typedef {import('../index.js').Settings} Settings
+*/
+/**
+* @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults
+*   Acceptable results from compilers.
+*
+*   To register custom results, add them to
+*   {@linkcode CompileResultMap}.
+*/
+/**
+* @template {Node} [Tree=Node]
+*   The node that the compiler receives (default: `Node`).
+* @template {CompileResults} [Result=CompileResults]
+*   The thing that the compiler yields (default: `CompileResults`).
+* @callback Compiler
+*   A **compiler** handles the compiling of a syntax tree to something else
+*   (in most cases, text) (TypeScript type).
+*
+*   It is used in the stringify phase and called with a {@linkcode Node}
+*   and {@linkcode VFile} representation of the document to compile.
+*   It should return the textual representation of the given tree (typically
+*   `string`).
+*
+*   > **Note**: unified typically compiles by serializing: most compilers
+*   > return `string` (or `Uint8Array`).
+*   > Some compilers, such as the one configured with
+*   > [`rehype-react`][rehype-react], return other values (in this case, a
+*   > React tree).
+*   > If you’re using a compiler that doesn’t serialize, expect different
+*   > result values.
+*   >
+*   > To register custom results in TypeScript, add them to
+*   > {@linkcode CompileResultMap}.
+*
+*   [rehype-react]: https://github.com/rehypejs/rehype-react
+* @param {Tree} tree
+*   Tree to compile.
+* @param {VFile} file
+*   File associated with `tree`.
+* @returns {Result}
+*   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or
+*   something else (for `file.result`).
+*/
+/**
+* @template {Node} [Tree=Node]
+*   The node that the parser yields (default: `Node`)
+* @callback Parser
+*   A **parser** handles the parsing of text to a syntax tree.
+*
+*   It is used in the parse phase and is called with a `string` and
+*   {@linkcode VFile} of the document to parse.
+*   It must return the syntax tree representation of the given file
+*   ({@linkcode Node}).
+* @param {string} document
+*   Document to parse.
+* @param {VFile} file
+*   File associated with `document`.
+* @returns {Tree}
+*   Node representing the given file.
+*/
+/**
+* @typedef {(
+*   Plugin<Array<any>, any, any> |
+*   PluginTuple<Array<any>, any, any> |
+*   Preset
+* )} Pluggable
+*   Union of the different ways to add plugins and settings.
+*/
+/**
+* @typedef {Array<Pluggable>} PluggableList
+*   List of plugins and presets.
+*/
+/**
+* @template {Array<unknown>} [PluginParameters=[]]
+*   Arguments passed to the plugin (default: `[]`, the empty tuple).
+* @template {Node | string | undefined} [Input=Node]
+*   Value that is expected as input (default: `Node`).
+*
+*   *   If the plugin returns a {@linkcode Transformer}, this
+*       should be the node it expects.
+*   *   If the plugin sets a {@linkcode Parser}, this should be
+*       `string`.
+*   *   If the plugin sets a {@linkcode Compiler}, this should be the
+*       node it expects.
+* @template [Output=Input]
+*   Value that is yielded as output (default: `Input`).
+*
+*   *   If the plugin returns a {@linkcode Transformer}, this
+*       should be the node that that yields.
+*   *   If the plugin sets a {@linkcode Parser}, this should be the
+*       node that it yields.
+*   *   If the plugin sets a {@linkcode Compiler}, this should be
+*       result it yields.
+* @typedef {(
+*   (this: Processor, ...parameters: PluginParameters) =>
+*     Input extends string ? // Parser.
+*        Output extends Node | undefined ? undefined | void : never :
+*     Output extends CompileResults ? // Compiler.
+*        Input extends Node | undefined ? undefined | void : never :
+*     Transformer<
+*       Input extends Node ? Input : Node,
+*       Output extends Node ? Output : Node
+*     > | undefined | void
+* )} Plugin
+*   Single plugin.
+*
+*   Plugins configure the processors they are applied on in the following
+*   ways:
+*
+*   *   they change the processor, such as the parser, the compiler, or by
+*       configuring data
+*   *   they specify how to handle trees and files
+*
+*   In practice, they are functions that can receive options and configure the
+*   processor (`this`).
+*
+*   > **Note**: plugins are called when the processor is *frozen*, not when
+*   > they are applied.
+*/
+/**
+* Tuple of a plugin and its configuration.
+*
+* The first item is a plugin, the rest are its parameters.
+*
+* @template {Array<unknown>} [TupleParameters=[]]
+*   Arguments passed to the plugin (default: `[]`, the empty tuple).
+* @template {Node | string | undefined} [Input=undefined]
+*   Value that is expected as input (optional).
+*
+*   *   If the plugin returns a {@linkcode Transformer}, this
+*       should be the node it expects.
+*   *   If the plugin sets a {@linkcode Parser}, this should be
+*       `string`.
+*   *   If the plugin sets a {@linkcode Compiler}, this should be the
+*       node it expects.
+* @template [Output=undefined] (optional).
+*   Value that is yielded as output.
+*
+*   *   If the plugin returns a {@linkcode Transformer}, this
+*       should be the node that that yields.
+*   *   If the plugin sets a {@linkcode Parser}, this should be the
+*       node that it yields.
+*   *   If the plugin sets a {@linkcode Compiler}, this should be
+*       result it yields.
+* @typedef {(
+*   [
+*     plugin: Plugin<TupleParameters, Input, Output>,
+*     ...parameters: TupleParameters
+*   ]
+* )} PluginTuple
+*/
+/**
+* @typedef Preset
+*   Sharable configuration.
+*
+*   They can contain plugins and settings.
+* @property {PluggableList | undefined} [plugins]
+*   List of plugins and presets (optional).
+* @property {Settings | undefined} [settings]
+*   Shared settings for parsers and compilers (optional).
+*/
+/**
+* @template {VFile} [File=VFile]
+*   The file that the callback receives (default: `VFile`).
+* @callback ProcessCallback
+*   Callback called when the process is done.
+*
+*   Called with either an error or a result.
+* @param {Error | undefined} [error]
+*   Fatal error (optional).
+* @param {File | undefined} [file]
+*   Processed file (optional).
+* @returns {undefined}
+*   Nothing.
+*/
+/**
+* @template {Node} [Tree=Node]
+*   The tree that the callback receives (default: `Node`).
+* @callback RunCallback
+*   Callback called when transformers are done.
+*
+*   Called with either an error or results.
+* @param {Error | undefined} [error]
+*   Fatal error (optional).
+* @param {Tree | undefined} [tree]
+*   Transformed tree (optional).
+* @param {VFile | undefined} [file]
+*   File (optional).
+* @returns {undefined}
+*   Nothing.
+*/
+/**
+* @template {Node} [Output=Node]
+*   Node type that the transformer yields (default: `Node`).
+* @callback TransformCallback
+*   Callback passed to transforms.
+*
+*   If the signature of a `transformer` accepts a third argument, the
+*   transformer may perform asynchronous operations, and must call it.
+* @param {Error | undefined} [error]
+*   Fatal error to stop the process (optional).
+* @param {Output | undefined} [tree]
+*   New, changed, tree (optional).
+* @param {VFile | undefined} [file]
+*   New, changed, file (optional).
+* @returns {undefined}
+*   Nothing.
+*/
+/**
+* @template {Node} [Input=Node]
+*   Node type that the transformer expects (default: `Node`).
+* @template {Node} [Output=Input]
+*   Node type that the transformer yields (default: `Input`).
+* @callback Transformer
+*   Transformers handle syntax trees and files.
+*
+*   They are functions that are called each time a syntax tree and file are
+*   passed through the run phase.
+*   When an error occurs in them (either because it’s thrown, returned,
+*   rejected, or passed to `next`), the process stops.
+*
+*   The run phase is handled by [`trough`][trough], see its documentation for
+*   the exact semantics of these functions.
+*
+*   > **Note**: you should likely ignore `next`: don’t accept it.
+*   > it supports callback-style async work.
+*   > But promises are likely easier to reason about.
+*
+*   [trough]: https://github.com/wooorm/trough#function-fninput-next
+* @param {Input} tree
+*   Tree to handle.
+* @param {VFile} file
+*   File to handle.
+* @param {TransformCallback<Output>} next
+*   Callback.
+* @returns {(
+*   Promise<Output | undefined | void> |
+*   Promise<never> | // For some reason this is needed separately.
+*   Output |
+*   Error |
+*   undefined |
+*   void
+* )}
+*   If you accept `next`, nothing.
+*   Otherwise:
+*
+*   *   `Error` — fatal error to stop the process
+*   *   `Promise<undefined>` or `undefined` — the next transformer keeps using
+*       same tree
+*   *   `Promise<Node>` or `Node` — new, changed, tree
+*/
+/**
+* @template {Node | undefined} ParseTree
+*   Output of `parse`.
+* @template {Node | undefined} HeadTree
+*   Input for `run`.
+* @template {Node | undefined} TailTree
+*   Output for `run`.
+* @template {Node | undefined} CompileTree
+*   Input of `stringify`.
+* @template {CompileResults | undefined} CompileResult
+*   Output of `stringify`.
+* @template {Node | string | undefined} Input
+*   Input of plugin.
+* @template Output
+*   Output of plugin (optional).
+* @typedef {(
+*   Input extends string
+*     ? Output extends Node | undefined
+*       ? // Parser.
+*         Processor<
+*           Output extends undefined ? ParseTree : Output,
+*           HeadTree,
+*           TailTree,
+*           CompileTree,
+*           CompileResult
+*         >
+*       : // Unknown.
+*         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
+*     : Output extends CompileResults
+*     ? Input extends Node | undefined
+*       ? // Compiler.
+*         Processor<
+*           ParseTree,
+*           HeadTree,
+*           TailTree,
+*           Input extends undefined ? CompileTree : Input,
+*           Output extends undefined ? CompileResult : Output
+*         >
+*       : // Unknown.
+*         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
+*     : Input extends Node | undefined
+*     ? Output extends Node | undefined
+*       ? // Transform.
+*         Processor<
+*           ParseTree,
+*           HeadTree extends undefined ? Input : HeadTree,
+*           Output extends undefined ? TailTree : Output,
+*           CompileTree,
+*           CompileResult
+*         >
+*       : // Unknown.
+*         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
+*     : // Unknown.
+*       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>
+* )} UsePlugin
+*   Create a processor based on the input/output of a {@link Plugin plugin}.
+*/
+/**
+* @template {CompileResults | undefined} Result
+*   Node type that the transformer yields.
+* @typedef {(
+*   Result extends Value | undefined ?
+*     VFile :
+*     VFile & {result: Result}
+*   )} VFileWithOutput
+*   Type to generate a {@linkcode VFile} corresponding to a compiler result.
+*
+*   If a result that is not acceptable on a `VFile` is used, that will
+*   be stored on the `result` field of {@linkcode VFile}.
+*/
 var import_extend = /* @__PURE__ */ __toESM(require_extend(), 1);
 const own$1 = {}.hasOwnProperty;
 /**
@@ -18191,6 +19407,61 @@ function escapeStringRegexp(string$2) {
 //#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`
@@ -18331,6 +19602,12 @@ function toFunction(replace$1) {
 
 //#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'
+*/
 /** @type {ConstructName} */
 const inConstruct = "phrasing";
 /** @type {Array<ConstructName>} */
@@ -18547,6 +19824,20 @@ function previous(match, email) {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-gfm-footnote@2.1.0/node_modules/mdast-util-gfm-footnote/lib/index.js
+/**
+* @import {
+*   CompileContext,
+*   Extension as FromMarkdownExtension,
+*   Handle as FromMarkdownHandle
+* } from 'mdast-util-from-markdown'
+* @import {ToMarkdownOptions} from 'mdast-util-gfm-footnote'
+* @import {
+*   Handle as ToMarkdownHandle,
+*   Map,
+*   Options as ToMarkdownExtension
+* } from 'mdast-util-to-markdown'
+* @import {FootnoteDefinition, FootnoteReference} from 'mdast'
+*/
 footnoteReference.peek = footnoteReferencePeek;
 /**
 * @this {CompileContext}
@@ -19118,6 +20409,35 @@ function toAlignment(value) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-gfm-table@2.0.0/node_modules/mdast-util-gfm-table/lib/index.js
 /**
+* @typedef {import('mdast').InlineCode} InlineCode
+* @typedef {import('mdast').Table} Table
+* @typedef {import('mdast').TableCell} TableCell
+* @typedef {import('mdast').TableRow} TableRow
+*
+* @typedef {import('markdown-table').Options} MarkdownTableOptions
+*
+* @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+*
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+* @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+* @typedef {import('mdast-util-to-markdown').State} State
+* @typedef {import('mdast-util-to-markdown').Info} Info
+*/
+/**
+* @typedef Options
+*   Configuration.
+* @property {boolean | null | undefined} [tableCellPadding=true]
+*   Whether to add a space of padding between delimiters and cells (default:
+*   `true`).
+* @property {boolean | null | undefined} [tablePipeAlign=true]
+*   Whether to align the delimiters (default: `true`).
+* @property {MarkdownTableOptions['stringLength'] | null | undefined} [stringLength]
+*   Function to detect the length of table cell content, used when aligning
+*   the delimiters between cells (optional).
+*/
+/**
 * Create an extension for `mdast-util-from-markdown` to enable GFM tables in
 * markdown.
 *
@@ -19355,6 +20675,15 @@ function gfmTableToMarkdown(options) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-gfm-task-list-item@2.0.0/node_modules/mdast-util-gfm-task-list-item/lib/index.js
 /**
+* @typedef {import('mdast').ListItem} ListItem
+* @typedef {import('mdast').Paragraph} Paragraph
+* @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+* @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+* @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+*/
+/**
 * Create an extension for `mdast-util-from-markdown` to enable GFM task
 * list items in markdown.
 *
@@ -19457,6 +20786,11 @@ function listItemWithTaskListItem(node$1, parent, state, info) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-gfm@3.1.0/node_modules/mdast-util-gfm/lib/index.js
 /**
+* @import {Extension as FromMarkdownExtension} from 'mdast-util-from-markdown'
+* @import {Options} from 'mdast-util-gfm'
+* @import {Options as ToMarkdownExtension} from 'mdast-util-to-markdown'
+*/
+/**
 * Create an extension for `mdast-util-from-markdown` to enable GFM (autolink
 * literals, footnotes, strikethrough, tables, tasklists).
 *
@@ -19495,6 +20829,9 @@ function gfmToMarkdown(options) {
 
 //#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
@@ -20194,6 +21531,9 @@ function previousUnbalanced(events) {
 
 //#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
@@ -20612,6 +21952,10 @@ function tokenizeIndent(effects, ok$2, nok) {
 //#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={}]
@@ -20882,6 +22226,16 @@ function gfmTableAlign(events, index$2) {
 //#endregion
 //#region node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/syntax.js
 /**
+* @import {Event, Extension, Point, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+/**
+* @typedef {[number, number, number, number]} Range
+*   Cell info.
+*
+* @typedef {0 | 1 | 2 | 3} RowKind
+*   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.
+*/
+/**
 * Create an HTML extension for `micromark` to support GitHub tables syntax.
 *
 * @returns {Extension}
@@ -21566,6 +22920,9 @@ function getPoint(events, index$2) {
 
 //#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
@@ -21684,6 +23041,12 @@ function spaceThenNonSpace(effects, ok$2, nok) {
 //#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]
@@ -21706,6 +23069,13 @@ function gfm(options) {
 
 //#endregion
 //#region node_modules/.pnpm/remark-gfm@4.0.1/node_modules/remark-gfm/lib/index.js
+/**
+* @import {Root} from 'mdast'
+* @import {Options} from 'remark-gfm'
+* @import {} from 'remark-parse'
+* @import {} from 'remark-stringify'
+* @import {Processor} from 'unified'
+*/
 /** @type {Options} */
 const emptyOptions = {};
 /**
@@ -21732,6 +23102,65 @@ function remarkGfm(options) {
 //#endregion
 //#region node_modules/.pnpm/to-vfile@8.0.0/node_modules/to-vfile/lib/index.js
 /**
+* @typedef {import('vfile').VFileOptions} Options
+* @typedef {import('vfile').VFileValue} Value
+*/
+/**
+* @typedef {'ascii' | 'base64' | 'base64url' | 'binary' | 'hex' | 'latin1' | 'ucs-2' | 'ucs2' | 'utf-8' | 'utf16le' | 'utf8'} BufferEncoding
+*   Encodings supported by the buffer class.
+*
+*   This is a copy of the types from Node, copied to prevent Node globals from
+*   being needed.
+*   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/1761eec/types/node/buffer.d.ts#L223>.
+*
+* @typedef ReadOptions
+*   Configuration for `fs.readFile`.
+* @property {BufferEncoding | null | undefined} [encoding]
+*   Encoding to read file as, will turn `file.value` into a string if passed.
+* @property {string | undefined} [flag]
+*   File system flags to use.
+*
+* @typedef WriteOptions
+*   Configuration for `fs.writeFile`.
+* @property {BufferEncoding | null | undefined} [encoding]
+*   Encoding to write file as.
+* @property {string | undefined} [flag]
+*   File system flags to use.
+* @property {number | string | undefined} [mode]
+*   File mode (permission and sticky bits) if the file was newly created.
+*
+* @typedef {URL | Value} Path
+*   URL to file or path to file.
+*
+*   > 👉 **Note**: `Value` is used here because it’s a smarter `Buffer`
+* @typedef {Options | Path | VFile} Compatible
+*   URL to file, path to file, options for file, or actual file.
+*/
+/**
+* @callback Callback
+*   Callback called after reading or writing a file.
+* @param {NodeJS.ErrnoException | undefined} error
+*   Error when reading or writing was not successful.
+* @param {VFile | null | undefined} file
+*   File when reading or writing was successful.
+* @returns {undefined}
+*   Nothing.
+*
+* @callback Resolve
+* @param {VFile} result
+*   File.
+* @returns {void}
+*   Nothing (note: has to be `void` for TSs `Promise` interface).
+*
+* @callback Reject
+* @param {NodeJS.ErrnoException} error
+*   Error.
+* @param {VFile | undefined} [result]
+*   File.
+* @returns {void}
+*   Nothing (note: has to be `void` for TSs `Promise` interface).
+*/
+/**
 * Create a virtual file and read it in, async.
 *
 * @overload
@@ -22460,6 +23889,61 @@ function toExpression(value) {
 
 //#endregion
 //#region node_modules/.pnpm/mdast-util-toc@7.1.0/node_modules/mdast-util-toc/lib/search.js
+/**
+* @typedef {import('mdast').Heading} Heading
+* @typedef {import('mdast').Nodes} Nodes
+* @typedef {import('mdast').PhrasingContent} PhrasingContent
+* @typedef {import('unist-util-is').Test} Test
+*/
+/**
+* @typedef {Heading['depth']} Rank
+*
+*/
+/**
+* @typedef SearchOptions
+*   Search configuration.
+* @property {Rank | null | undefined} [maxDepth=6]
+*   Maximum heading depth to include in the table of contents (default: `6`).
+*
+*   This is inclusive: when set to `3`, level three headings are included
+*   (those with three hashes, `###`).
+* @property {Rank | null | undefined} [minDepth=1]
+*   Minimum heading depth to include in the table of contents (default: `1`).
+*
+*   This is inclusive: when set to `3`, level three headings are included
+*   (those with three hashes, `###`).
+* @property {string | null | undefined} [skip]
+*   Headings to skip, wrapped in `new RegExp('^(' + value + ')$', 'i')`
+*   (default: `undefined`).
+*
+*   Any heading matching this expression will not be present in the table of
+*   contents.
+* @property {Test} [parents]
+*   Allow headings to be children of certain node types (default: the to `toc`
+*   given `tree`, to only allow top-level headings) (default:
+*   `d => d === tree`).
+*
+*   Internally, uses `unist-util-is` to check, so `parents` can be any
+*   `is`-compatible test.
+*
+* @typedef SearchEntry
+*   Entry.
+* @property {string} id
+*   ID of entry.
+* @property {Array<PhrasingContent>} children
+*   Contents of entry.
+* @property {Rank} depth
+*   Rank of entry.
+*
+* @typedef SearchResult
+*   Results.
+* @property {number} index
+*   Where the contents section starts, if looking for a heading.
+* @property {number} endIndex
+*   Where the contents section ends, if looking for a heading.
+* @property {Array<SearchEntry>} map
+*   List of entries.
+*/
 const slugs = new BananaSlug();
 /**
 * Search a node for a toc.
@@ -22724,6 +24208,27 @@ var esm_default = typeof structuredClone === "function" ? (any, options) => opti
 //#endregion
 //#region node_modules/.pnpm/mdast-util-toc@7.1.0/node_modules/mdast-util-toc/lib/contents.js
 /**
+* @typedef {import('mdast').List} List
+* @typedef {import('mdast').ListItem} ListItem
+* @typedef {import('mdast').PhrasingContent} PhrasingContent
+* @typedef {import('./search.js').SearchEntry} SearchEntry
+*/
+/**
+* @typedef ContentsOptions
+*   Build configuration.
+* @property {boolean | null | undefined} [tight=false]
+*   Whether to compile list items tightly (default: `false`).
+* @property {boolean | null | undefined} [ordered=false]
+*   Whether to compile list items as an ordered list, otherwise they are
+*   unordered (default: `false`).
+* @property {string | null | undefined} [prefix=undefined]
+*   Add a prefix to links to headings in the table of contents (default:
+*   `undefined`).
+*
+*   Useful for example when later going from mdast to hast and sanitizing with
+*   `hast-util-sanitize`.
+*/
+/**
 * Transform a list of heading objects to a markdown list.
 *
 * @param {Array<SearchEntry>} map
@@ -22843,6 +24348,36 @@ function one(node$1) {
 //#endregion
 //#region node_modules/.pnpm/mdast-util-toc@7.1.0/node_modules/mdast-util-toc/lib/index.js
 /**
+* @typedef {import('mdast').List} List
+* @typedef {import('mdast').Nodes} Nodes
+* @typedef {import('./search.js').SearchOptions} SearchOptions
+* @typedef {import('./contents.js').ContentsOptions} ContentsOptions
+*/
+/**
+* @typedef {ContentsOptions & ExtraOptions & SearchOptions} Options
+*
+* @typedef ExtraOptions
+*   Extra configuration fields.
+* @property {string | null | undefined} [heading]
+*   Heading to look for, wrapped in `new RegExp('^(' + value + ')$', 'i')`
+*   (default: `undefined`).
+*
+* @typedef Result
+*   Results.
+* @property {number | undefined} index
+*   Index of the node right after the table of contents heading, `-1` if no
+*   heading was found, `undefined` if no `heading` was given.
+* @property {number | undefined} endIndex
+*   Index of the first node after `heading` that is not part of its section,
+*   `-1` if no heading was found, `undefined` if no `heading` was given, same
+*   as `index` if there are no nodes between `heading` and the first heading
+*   in the table of contents.
+* @property {List | undefined} map
+*   List representing the generated table of contents, `undefined` if no table
+*   of contents could be created, either because no heading was found or
+*   because no following headings were found.
+*/
+/**
 * Generate a table of contents from `tree`.
 *
 * Looks for the first heading matching `options.heading` (case insensitive) and