@alivault/pico 0.14.0 → 0.16.1

package/.output/server/_libs/mdast-util-to-hast+[...].mjs

@@ -1,1771 +0,0 @@
-import "./devlop.mjs";
-import { a as pointEnd, n as visit, o as pointStart, s as position } from "./hast-util-raw+[...].mjs";
-import { s as asciiAlphanumeric } from "./mdast-util-from-markdown+[...].mjs";
-import { t as esm_default } from "./ungap__structured-clone.mjs";
-//#region node_modules/.pnpm/micromark-util-sanitize-uri@2.0.1/node_modules/micromark-util-sanitize-uri/index.js
-/**
-* Normalize a URL.
-*
-* Encode unsafe characters with percent-encoding, skipping already encoded
-* sequences.
-*
-* @param {string} value
-*   URI to normalize.
-* @returns {string}
-*   Normalized URI.
-*/
-function normalizeUri(value) {
-	/** @type {Array<string>} */
-	const result = [];
-	let index = -1;
-	let start = 0;
-	let skip = 0;
-	while (++index < value.length) {
-		const code = value.charCodeAt(index);
-		/** @type {string} */
-		let replace = "";
-		if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) skip = 2;
-		else if (code < 128) {
-			if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) replace = String.fromCharCode(code);
-		} else if (code > 55295 && code < 57344) {
-			const next = value.charCodeAt(index + 1);
-			if (code < 56320 && next > 56319 && next < 57344) {
-				replace = String.fromCharCode(code, next);
-				skip = 1;
-			} else replace = "�";
-		} else replace = String.fromCharCode(code);
-		if (replace) {
-			result.push(value.slice(start, index), encodeURIComponent(replace));
-			start = index + skip + 1;
-			replace = "";
-		}
-		if (skip) {
-			index += skip;
-			skip = 0;
-		}
-	}
-	return result.join("") + value.slice(start);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/blockquote.js
-/**
-* @import {Element} from 'hast'
-* @import {Blockquote} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `blockquote` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Blockquote} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function blockquote(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "blockquote",
-		properties: {},
-		children: state.wrap(state.all(node), true)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/break.js
-/**
-* @import {Element, Text} from 'hast'
-* @import {Break} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `break` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Break} node
-*   mdast node.
-* @returns {Array<Element | Text>}
-*   hast element content.
-*/
-function hardBreak(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "br",
-		properties: {},
-		children: []
-	};
-	state.patch(node, result);
-	return [state.applyData(node, result), {
-		type: "text",
-		value: "\n"
-	}];
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/code.js
-/**
-* @import {Element, Properties} from 'hast'
-* @import {Code} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `code` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Code} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function code(state, node) {
-	const value = node.value ? node.value + "\n" : "";
-	/** @type {Properties} */
-	const properties = {};
-	const language = node.lang ? node.lang.split(/\s+/) : [];
-	if (language.length > 0) properties.className = ["language-" + language[0]];
-	/** @type {Element} */
-	let result = {
-		type: "element",
-		tagName: "code",
-		properties,
-		children: [{
-			type: "text",
-			value
-		}]
-	};
-	if (node.meta) result.data = { meta: node.meta };
-	state.patch(node, result);
-	result = state.applyData(node, result);
-	result = {
-		type: "element",
-		tagName: "pre",
-		properties: {},
-		children: [result]
-	};
-	state.patch(node, result);
-	return result;
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/delete.js
-/**
-* @import {Element} from 'hast'
-* @import {Delete} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `delete` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Delete} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function strikethrough(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "del",
-		properties: {},
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/emphasis.js
-/**
-* @import {Element} from 'hast'
-* @import {Emphasis} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `emphasis` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Emphasis} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function emphasis(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "em",
-		properties: {},
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js
-/**
-* @import {Element} from 'hast'
-* @import {FootnoteReference} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `footnoteReference` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {FootnoteReference} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function footnoteReference(state, node) {
-	const clobberPrefix = typeof state.options.clobberPrefix === "string" ? state.options.clobberPrefix : "user-content-";
-	const id = String(node.identifier).toUpperCase();
-	const safeId = normalizeUri(id.toLowerCase());
-	const index = state.footnoteOrder.indexOf(id);
-	/** @type {number} */
-	let counter;
-	let reuseCounter = state.footnoteCounts.get(id);
-	if (reuseCounter === void 0) {
-		reuseCounter = 0;
-		state.footnoteOrder.push(id);
-		counter = state.footnoteOrder.length;
-	} else counter = index + 1;
-	reuseCounter += 1;
-	state.footnoteCounts.set(id, reuseCounter);
-	/** @type {Element} */
-	const link = {
-		type: "element",
-		tagName: "a",
-		properties: {
-			href: "#" + clobberPrefix + "fn-" + safeId,
-			id: clobberPrefix + "fnref-" + safeId + (reuseCounter > 1 ? "-" + reuseCounter : ""),
-			dataFootnoteRef: true,
-			ariaDescribedBy: ["footnote-label"]
-		},
-		children: [{
-			type: "text",
-			value: String(counter)
-		}]
-	};
-	state.patch(node, link);
-	/** @type {Element} */
-	const sup = {
-		type: "element",
-		tagName: "sup",
-		properties: {},
-		children: [link]
-	};
-	state.patch(node, sup);
-	return state.applyData(node, sup);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/heading.js
-/**
-* @import {Element} from 'hast'
-* @import {Heading} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `heading` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Heading} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function heading(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "h" + node.depth,
-		properties: {},
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/html.js
-/**
-* @import {Element} from 'hast'
-* @import {Html} from 'mdast'
-* @import {State} from '../state.js'
-* @import {Raw} from '../../index.js'
-*/
-/**
-* Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise
-* nothing).
-*
-* @param {State} state
-*   Info passed around.
-* @param {Html} node
-*   mdast node.
-* @returns {Element | Raw | undefined}
-*   hast node.
-*/
-function html(state, node) {
-	if (state.options.allowDangerousHtml) {
-		/** @type {Raw} */
-		const result = {
-			type: "raw",
-			value: node.value
-		};
-		state.patch(node, result);
-		return state.applyData(node, result);
-	}
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/revert.js
-/**
-* @import {ElementContent} from 'hast'
-* @import {Reference, Nodes} from 'mdast'
-* @import {State} from './state.js'
-*/
-/**
-* Return the content of a reference without definition as plain text.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Extract<Nodes, Reference>} node
-*   Reference node (image, link).
-* @returns {Array<ElementContent>}
-*   hast content.
-*/
-function revert(state, node) {
-	const subtype = node.referenceType;
-	let suffix = "]";
-	if (subtype === "collapsed") suffix += "[]";
-	else if (subtype === "full") suffix += "[" + (node.label || node.identifier) + "]";
-	if (node.type === "imageReference") return [{
-		type: "text",
-		value: "![" + node.alt + suffix
-	}];
-	const contents = state.all(node);
-	const head = contents[0];
-	if (head && head.type === "text") head.value = "[" + head.value;
-	else contents.unshift({
-		type: "text",
-		value: "["
-	});
-	const tail = contents[contents.length - 1];
-	if (tail && tail.type === "text") tail.value += suffix;
-	else contents.push({
-		type: "text",
-		value: suffix
-	});
-	return contents;
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/image-reference.js
-/**
-* @import {ElementContent, Element, Properties} from 'hast'
-* @import {ImageReference} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `imageReference` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {ImageReference} node
-*   mdast node.
-* @returns {Array<ElementContent> | ElementContent}
-*   hast node.
-*/
-function imageReference(state, node) {
-	const id = String(node.identifier).toUpperCase();
-	const definition = state.definitionById.get(id);
-	if (!definition) return revert(state, node);
-	/** @type {Properties} */
-	const properties = {
-		src: normalizeUri(definition.url || ""),
-		alt: node.alt
-	};
-	if (definition.title !== null && definition.title !== void 0) properties.title = definition.title;
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "img",
-		properties,
-		children: []
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/image.js
-/**
-* @import {Element, Properties} from 'hast'
-* @import {Image} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `image` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Image} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function image(state, node) {
-	/** @type {Properties} */
-	const properties = { src: normalizeUri(node.url) };
-	if (node.alt !== null && node.alt !== void 0) properties.alt = node.alt;
-	if (node.title !== null && node.title !== void 0) properties.title = node.title;
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "img",
-		properties,
-		children: []
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/inline-code.js
-/**
-* @import {Element, Text} from 'hast'
-* @import {InlineCode} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `inlineCode` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {InlineCode} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function inlineCode(state, node) {
-	/** @type {Text} */
-	const text = {
-		type: "text",
-		value: node.value.replace(/\r?\n|\r/g, " ")
-	};
-	state.patch(node, text);
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "code",
-		properties: {},
-		children: [text]
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/link-reference.js
-/**
-* @import {ElementContent, Element, Properties} from 'hast'
-* @import {LinkReference} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `linkReference` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {LinkReference} node
-*   mdast node.
-* @returns {Array<ElementContent> | ElementContent}
-*   hast node.
-*/
-function linkReference(state, node) {
-	const id = String(node.identifier).toUpperCase();
-	const definition = state.definitionById.get(id);
-	if (!definition) return revert(state, node);
-	/** @type {Properties} */
-	const properties = { href: normalizeUri(definition.url || "") };
-	if (definition.title !== null && definition.title !== void 0) properties.title = definition.title;
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "a",
-		properties,
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/link.js
-/**
-* @import {Element, Properties} from 'hast'
-* @import {Link} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `link` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Link} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function link(state, node) {
-	/** @type {Properties} */
-	const properties = { href: normalizeUri(node.url) };
-	if (node.title !== null && node.title !== void 0) properties.title = node.title;
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "a",
-		properties,
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/list-item.js
-/**
-* @import {ElementContent, Element, Properties} from 'hast'
-* @import {ListItem, Parents} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `listItem` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {ListItem} node
-*   mdast node.
-* @param {Parents | undefined} parent
-*   Parent of `node`.
-* @returns {Element}
-*   hast node.
-*/
-function listItem(state, node, parent) {
-	const results = state.all(node);
-	const loose = parent ? listLoose(parent) : listItemLoose(node);
-	/** @type {Properties} */
-	const properties = {};
-	/** @type {Array<ElementContent>} */
-	const children = [];
-	if (typeof node.checked === "boolean") {
-		const head = results[0];
-		/** @type {Element} */
-		let paragraph;
-		if (head && head.type === "element" && head.tagName === "p") paragraph = head;
-		else {
-			paragraph = {
-				type: "element",
-				tagName: "p",
-				properties: {},
-				children: []
-			};
-			results.unshift(paragraph);
-		}
-		if (paragraph.children.length > 0) paragraph.children.unshift({
-			type: "text",
-			value: " "
-		});
-		paragraph.children.unshift({
-			type: "element",
-			tagName: "input",
-			properties: {
-				type: "checkbox",
-				checked: node.checked,
-				disabled: true
-			},
-			children: []
-		});
-		properties.className = ["task-list-item"];
-	}
-	let index = -1;
-	while (++index < results.length) {
-		const child = results[index];
-		if (loose || index !== 0 || child.type !== "element" || child.tagName !== "p") children.push({
-			type: "text",
-			value: "\n"
-		});
-		if (child.type === "element" && child.tagName === "p" && !loose) children.push(...child.children);
-		else children.push(child);
-	}
-	const tail = results[results.length - 1];
-	if (tail && (loose || tail.type !== "element" || tail.tagName !== "p")) children.push({
-		type: "text",
-		value: "\n"
-	});
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "li",
-		properties,
-		children
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-/**
-* @param {Parents} node
-* @return {Boolean}
-*/
-function listLoose(node) {
-	let loose = false;
-	if (node.type === "list") {
-		loose = node.spread || false;
-		const children = node.children;
-		let index = -1;
-		while (!loose && ++index < children.length) loose = listItemLoose(children[index]);
-	}
-	return loose;
-}
-/**
-* @param {ListItem} node
-* @return {Boolean}
-*/
-function listItemLoose(node) {
-	const spread = node.spread;
-	return spread === null || spread === void 0 ? node.children.length > 1 : spread;
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/list.js
-/**
-* @import {Element, Properties} from 'hast'
-* @import {List} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `list` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {List} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function list(state, node) {
-	/** @type {Properties} */
-	const properties = {};
-	const results = state.all(node);
-	let index = -1;
-	if (typeof node.start === "number" && node.start !== 1) properties.start = node.start;
-	while (++index < results.length) {
-		const child = results[index];
-		if (child.type === "element" && child.tagName === "li" && child.properties && Array.isArray(child.properties.className) && child.properties.className.includes("task-list-item")) {
-			properties.className = ["contains-task-list"];
-			break;
-		}
-	}
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: node.ordered ? "ol" : "ul",
-		properties,
-		children: state.wrap(results, true)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/paragraph.js
-/**
-* @import {Element} from 'hast'
-* @import {Paragraph} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `paragraph` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Paragraph} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function paragraph(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "p",
-		properties: {},
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/root.js
-/**
-* @import {Parents as HastParents, Root as HastRoot} from 'hast'
-* @import {Root as MdastRoot} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `root` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {MdastRoot} node
-*   mdast node.
-* @returns {HastParents}
-*   hast node.
-*/
-function root(state, node) {
-	/** @type {HastRoot} */
-	const result = {
-		type: "root",
-		children: state.wrap(state.all(node))
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/strong.js
-/**
-* @import {Element} from 'hast'
-* @import {Strong} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `strong` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Strong} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function strong(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "strong",
-		properties: {},
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/table.js
-/**
-* @import {Table} from 'mdast'
-* @import {Element} from 'hast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `table` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {Table} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function table(state, node) {
-	const rows = state.all(node);
-	const firstRow = rows.shift();
-	/** @type {Array<Element>} */
-	const tableContent = [];
-	if (firstRow) {
-		/** @type {Element} */
-		const head = {
-			type: "element",
-			tagName: "thead",
-			properties: {},
-			children: state.wrap([firstRow], true)
-		};
-		state.patch(node.children[0], head);
-		tableContent.push(head);
-	}
-	if (rows.length > 0) {
-		/** @type {Element} */
-		const body = {
-			type: "element",
-			tagName: "tbody",
-			properties: {},
-			children: state.wrap(rows, true)
-		};
-		const start = pointStart(node.children[1]);
-		const end = pointEnd(node.children[node.children.length - 1]);
-		if (start && end) body.position = {
-			start,
-			end
-		};
-		tableContent.push(body);
-	}
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "table",
-		properties: {},
-		children: state.wrap(tableContent, true)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/table-row.js
-/**
-* @import {Element, ElementContent, Properties} from 'hast'
-* @import {Parents, TableRow} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `tableRow` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {TableRow} node
-*   mdast node.
-* @param {Parents | undefined} parent
-*   Parent of `node`.
-* @returns {Element}
-*   hast node.
-*/
-function tableRow(state, node, parent) {
-	const siblings = parent ? parent.children : void 0;
-	const tagName = (siblings ? siblings.indexOf(node) : 1) === 0 ? "th" : "td";
-	const align = parent && parent.type === "table" ? parent.align : void 0;
-	const length = align ? align.length : node.children.length;
-	let cellIndex = -1;
-	/** @type {Array<ElementContent>} */
-	const cells = [];
-	while (++cellIndex < length) {
-		const cell = node.children[cellIndex];
-		/** @type {Properties} */
-		const properties = {};
-		const alignValue = align ? align[cellIndex] : void 0;
-		if (alignValue) properties.align = alignValue;
-		/** @type {Element} */
-		let result = {
-			type: "element",
-			tagName,
-			properties,
-			children: []
-		};
-		if (cell) {
-			result.children = state.all(cell);
-			state.patch(cell, result);
-			result = state.applyData(cell, result);
-		}
-		cells.push(result);
-	}
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "tr",
-		properties: {},
-		children: state.wrap(cells, true)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/table-cell.js
-/**
-* @import {Element} from 'hast'
-* @import {TableCell} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `tableCell` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {TableCell} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function tableCell(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "td",
-		properties: {},
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/trim-lines@3.0.1/node_modules/trim-lines/index.js
-var tab = 9;
-var space = 32;
-/**
-* Remove initial and final spaces and tabs at the line breaks in `value`.
-* Does not trim initial and final spaces and tabs of the value itself.
-*
-* @param {string} value
-*   Value to trim.
-* @returns {string}
-*   Trimmed value.
-*/
-function trimLines(value) {
-	const source = String(value);
-	const search = /\r?\n|\r/g;
-	let match = search.exec(source);
-	let last = 0;
-	/** @type {Array<string>} */
-	const lines = [];
-	while (match) {
-		lines.push(trimLine(source.slice(last, match.index), last > 0, true), match[0]);
-		last = match.index + match[0].length;
-		match = search.exec(source);
-	}
-	lines.push(trimLine(source.slice(last), last > 0, false));
-	return lines.join("");
-}
-/**
-* @param {string} value
-*   Line to trim.
-* @param {boolean} start
-*   Whether to trim the start of the line.
-* @param {boolean} end
-*   Whether to trim the end of the line.
-* @returns {string}
-*   Trimmed line.
-*/
-function trimLine(value, start, end) {
-	let startIndex = 0;
-	let endIndex = value.length;
-	if (start) {
-		let code = value.codePointAt(startIndex);
-		while (code === tab || code === space) {
-			startIndex++;
-			code = value.codePointAt(startIndex);
-		}
-	}
-	if (end) {
-		let code = value.codePointAt(endIndex - 1);
-		while (code === tab || code === space) {
-			endIndex--;
-			code = value.codePointAt(endIndex - 1);
-		}
-	}
-	return endIndex > startIndex ? value.slice(startIndex, endIndex) : "";
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/text.js
-/**
-* @import {Element as HastElement, Text as HastText} from 'hast'
-* @import {Text as MdastText} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `text` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {MdastText} node
-*   mdast node.
-* @returns {HastElement | HastText}
-*   hast node.
-*/
-function text(state, node) {
-	/** @type {HastText} */
-	const result = {
-		type: "text",
-		value: trimLines(String(node.value))
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js
-/**
-* @import {Element} from 'hast'
-* @import {ThematicBreak} from 'mdast'
-* @import {State} from '../state.js'
-*/
-/**
-* Turn an mdast `thematicBreak` node into hast.
-*
-* @param {State} state
-*   Info passed around.
-* @param {ThematicBreak} node
-*   mdast node.
-* @returns {Element}
-*   hast node.
-*/
-function thematicBreak(state, node) {
-	/** @type {Element} */
-	const result = {
-		type: "element",
-		tagName: "hr",
-		properties: {},
-		children: []
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/handlers/index.js
-/**
-* @import {Handlers} from '../state.js'
-*/
-/**
-* Default handlers for nodes.
-*
-* @satisfies {Handlers}
-*/
-var handlers = {
-	blockquote,
-	break: hardBreak,
-	code,
-	delete: strikethrough,
-	emphasis,
-	footnoteReference,
-	heading,
-	html,
-	imageReference,
-	image,
-	inlineCode,
-	linkReference,
-	link,
-	listItem,
-	list,
-	paragraph,
-	root,
-	strong,
-	table,
-	tableCell,
-	tableRow,
-	text,
-	thematicBreak,
-	toml: ignore,
-	yaml: ignore,
-	definition: ignore,
-	footnoteDefinition: ignore
-};
-function ignore() {}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/footer.js
-/**
-* @import {ElementContent, Element} from 'hast'
-* @import {State} from './state.js'
-*/
-/**
-* @callback FootnoteBackContentTemplate
-*   Generate content for the backreference dynamically.
-*
-*   For the following markdown:
-*
-*   ```markdown
-*   Alpha[^micromark], bravo[^micromark], and charlie[^remark].
-*
-*   [^remark]: things about remark
-*   [^micromark]: things about micromark
-*   ```
-*
-*   This function will be called with:
-*
-*   *  `0` and `0` for the backreference from `things about micromark` to
-*      `alpha`, as it is the first used definition, and the first call to it
-*   *  `0` and `1` for the backreference from `things about micromark` to
-*      `bravo`, as it is the first used definition, and the second call to it
-*   *  `1` and `0` for the backreference from `things about remark` to
-*      `charlie`, as it is the second used definition
-* @param {number} referenceIndex
-*   Index of the definition in the order that they are first referenced,
-*   0-indexed.
-* @param {number} rereferenceIndex
-*   Index of calls to the same definition, 0-indexed.
-* @returns {Array<ElementContent> | ElementContent | string}
-*   Content for the backreference when linking back from definitions to their
-*   reference.
-*
-* @callback FootnoteBackLabelTemplate
-*   Generate a back label dynamically.
-*
-*   For the following markdown:
-*
-*   ```markdown
-*   Alpha[^micromark], bravo[^micromark], and charlie[^remark].
-*
-*   [^remark]: things about remark
-*   [^micromark]: things about micromark
-*   ```
-*
-*   This function will be called with:
-*
-*   *  `0` and `0` for the backreference from `things about micromark` to
-*      `alpha`, as it is the first used definition, and the first call to it
-*   *  `0` and `1` for the backreference from `things about micromark` to
-*      `bravo`, as it is the first used definition, and the second call to it
-*   *  `1` and `0` for the backreference from `things about remark` to
-*      `charlie`, as it is the second used definition
-* @param {number} referenceIndex
-*   Index of the definition in the order that they are first referenced,
-*   0-indexed.
-* @param {number} rereferenceIndex
-*   Index of calls to the same definition, 0-indexed.
-* @returns {string}
-*   Back label to use when linking back from definitions to their reference.
-*/
-/**
-* Generate the default content that GitHub uses on backreferences.
-*
-* @param {number} _
-*   Index of the definition in the order that they are first referenced,
-*   0-indexed.
-* @param {number} rereferenceIndex
-*   Index of calls to the same definition, 0-indexed.
-* @returns {Array<ElementContent>}
-*   Content.
-*/
-function defaultFootnoteBackContent(_, rereferenceIndex) {
-	/** @type {Array<ElementContent>} */
-	const result = [{
-		type: "text",
-		value: "↩"
-	}];
-	if (rereferenceIndex > 1) result.push({
-		type: "element",
-		tagName: "sup",
-		properties: {},
-		children: [{
-			type: "text",
-			value: String(rereferenceIndex)
-		}]
-	});
-	return result;
-}
-/**
-* Generate the default label that GitHub uses on backreferences.
-*
-* @param {number} referenceIndex
-*   Index of the definition in the order that they are first referenced,
-*   0-indexed.
-* @param {number} rereferenceIndex
-*   Index of calls to the same definition, 0-indexed.
-* @returns {string}
-*   Label.
-*/
-function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
-	return "Back to reference " + (referenceIndex + 1) + (rereferenceIndex > 1 ? "-" + rereferenceIndex : "");
-}
-/**
-* Generate a hast footer for called footnote definitions.
-*
-* @param {State} state
-*   Info passed around.
-* @returns {Element | undefined}
-*   `section` element or `undefined`.
-*/
-function footer(state) {
-	const clobberPrefix = typeof state.options.clobberPrefix === "string" ? state.options.clobberPrefix : "user-content-";
-	const footnoteBackContent = state.options.footnoteBackContent || defaultFootnoteBackContent;
-	const footnoteBackLabel = state.options.footnoteBackLabel || defaultFootnoteBackLabel;
-	const footnoteLabel = state.options.footnoteLabel || "Footnotes";
-	const footnoteLabelTagName = state.options.footnoteLabelTagName || "h2";
-	const footnoteLabelProperties = state.options.footnoteLabelProperties || { className: ["sr-only"] };
-	/** @type {Array<ElementContent>} */
-	const listItems = [];
-	let referenceIndex = -1;
-	while (++referenceIndex < state.footnoteOrder.length) {
-		const definition = state.footnoteById.get(state.footnoteOrder[referenceIndex]);
-		if (!definition) continue;
-		const content = state.all(definition);
-		const id = String(definition.identifier).toUpperCase();
-		const safeId = normalizeUri(id.toLowerCase());
-		let rereferenceIndex = 0;
-		/** @type {Array<ElementContent>} */
-		const backReferences = [];
-		const counts = state.footnoteCounts.get(id);
-		while (counts !== void 0 && ++rereferenceIndex <= counts) {
-			if (backReferences.length > 0) backReferences.push({
-				type: "text",
-				value: " "
-			});
-			let children = typeof footnoteBackContent === "string" ? footnoteBackContent : footnoteBackContent(referenceIndex, rereferenceIndex);
-			if (typeof children === "string") children = {
-				type: "text",
-				value: children
-			};
-			backReferences.push({
-				type: "element",
-				tagName: "a",
-				properties: {
-					href: "#" + clobberPrefix + "fnref-" + safeId + (rereferenceIndex > 1 ? "-" + rereferenceIndex : ""),
-					dataFootnoteBackref: "",
-					ariaLabel: typeof footnoteBackLabel === "string" ? footnoteBackLabel : footnoteBackLabel(referenceIndex, rereferenceIndex),
-					className: ["data-footnote-backref"]
-				},
-				children: Array.isArray(children) ? children : [children]
-			});
-		}
-		const tail = content[content.length - 1];
-		if (tail && tail.type === "element" && tail.tagName === "p") {
-			const tailTail = tail.children[tail.children.length - 1];
-			if (tailTail && tailTail.type === "text") tailTail.value += " ";
-			else tail.children.push({
-				type: "text",
-				value: " "
-			});
-			tail.children.push(...backReferences);
-		} else content.push(...backReferences);
-		/** @type {Element} */
-		const listItem = {
-			type: "element",
-			tagName: "li",
-			properties: { id: clobberPrefix + "fn-" + safeId },
-			children: state.wrap(content, true)
-		};
-		state.patch(definition, listItem);
-		listItems.push(listItem);
-	}
-	if (listItems.length === 0) return;
-	return {
-		type: "element",
-		tagName: "section",
-		properties: {
-			dataFootnotes: true,
-			className: ["footnotes"]
-		},
-		children: [
-			{
-				type: "element",
-				tagName: footnoteLabelTagName,
-				properties: {
-					...esm_default(footnoteLabelProperties),
-					id: "footnote-label"
-				},
-				children: [{
-					type: "text",
-					value: footnoteLabel
-				}]
-			},
-			{
-				type: "text",
-				value: "\n"
-			},
-			{
-				type: "element",
-				tagName: "ol",
-				properties: {},
-				children: state.wrap(listItems, true)
-			},
-			{
-				type: "text",
-				value: "\n"
-			}
-		]
-	};
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/state.js
-/**
-* @import {
-*   ElementContent as HastElementContent,
-*   Element as HastElement,
-*   Nodes as HastNodes,
-*   Properties as HastProperties,
-*   RootContent as HastRootContent,
-*   Text as HastText
-* } from 'hast'
-* @import {
-*   Definition as MdastDefinition,
-*   FootnoteDefinition as MdastFootnoteDefinition,
-*   Nodes as MdastNodes,
-*   Parents as MdastParents
-* } from 'mdast'
-* @import {VFile} from 'vfile'
-* @import {
-*   FootnoteBackContentTemplate,
-*   FootnoteBackLabelTemplate
-* } from './footer.js'
-*/
-/**
-* @callback Handler
-*   Handle a node.
-* @param {State} state
-*   Info passed around.
-* @param {any} node
-*   mdast node to handle.
-* @param {MdastParents | undefined} parent
-*   Parent of `node`.
-* @returns {Array<HastElementContent> | HastElementContent | undefined}
-*   hast node.
-*
-* @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers
-*   Handle nodes.
-*
-* @typedef Options
-*   Configuration (optional).
-* @property {boolean | null | undefined} [allowDangerousHtml=false]
-*   Whether to persist raw HTML in markdown in the hast tree (default:
-*   `false`).
-* @property {string | null | undefined} [clobberPrefix='user-content-']
-*   Prefix to use before the `id` property on footnotes to prevent them from
-*   *clobbering* (default: `'user-content-'`).
-*
-*   Pass `''` for trusted markdown and when you are careful with
-*   polyfilling.
-*   You could pass a different prefix.
-*
-*   DOM clobbering is this:
-*
-*   ```html
-*   <p id="x"></p>
-*   <script>alert(x) // `x` now refers to the `p#x` DOM element<\/script>
-*   ```
-*
-*   The above example shows that elements are made available by browsers, by
-*   their ID, on the `window` object.
-*   This is a security risk because you might be expecting some other variable
-*   at that place.
-*   It can also break polyfills.
-*   Using a prefix solves these problems.
-* @property {VFile | null | undefined} [file]
-*   Corresponding virtual file representing the input document (optional).
-* @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]
-*   Content of the backreference back to references (default: `defaultFootnoteBackContent`).
-*
-*   The default value is:
-*
-*   ```js
-*   function defaultFootnoteBackContent(_, rereferenceIndex) {
-*     const result = [{type: 'text', value: '↩'}]
-*
-*     if (rereferenceIndex > 1) {
-*       result.push({
-*         type: 'element',
-*         tagName: 'sup',
-*         properties: {},
-*         children: [{type: 'text', value: String(rereferenceIndex)}]
-*       })
-*     }
-*
-*     return result
-*   }
-*   ```
-*
-*   This content is used in the `a` element of each backreference (the `↩`
-*   links).
-* @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]
-*   Label to describe the backreference back to references (default:
-*   `defaultFootnoteBackLabel`).
-*
-*   The default value is:
-*
-*   ```js
-*   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
-*    return (
-*      'Back to reference ' +
-*      (referenceIndex + 1) +
-*      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')
-*    )
-*   }
-*   ```
-*
-*   Change it when the markdown is not in English.
-*
-*   This label is used in the `ariaLabel` property on each backreference
-*   (the `↩` links).
-*   It affects users of assistive technology.
-* @property {string | null | undefined} [footnoteLabel='Footnotes']
-*   Textual label to use for the footnotes section (default: `'Footnotes'`).
-*
-*   Change it when the markdown is not in English.
-*
-*   This label is typically hidden visually (assuming a `sr-only` CSS class
-*   is defined that does that) and so affects screen readers only.
-*   If you do have such a class, but want to show this section to everyone,
-*   pass different properties with the `footnoteLabelProperties` option.
-* @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]
-*   Properties to use on the footnote label (default: `{className:
-*   ['sr-only']}`).
-*
-*   Change it to show the label and add other properties.
-*
-*   This label is typically hidden visually (assuming an `sr-only` CSS class
-*   is defined that does that) and so affects screen readers only.
-*   If you do have such a class, but want to show this section to everyone,
-*   pass an empty string.
-*   You can also add different properties.
-*
-*   > **Note**: `id: 'footnote-label'` is always added, because footnote
-*   > calls use it with `aria-describedby` to provide an accessible label.
-* @property {string | null | undefined} [footnoteLabelTagName='h2']
-*   HTML tag name to use for the footnote label element (default: `'h2'`).
-*
-*   Change it to match your document structure.
-*
-*   This label is typically hidden visually (assuming a `sr-only` CSS class
-*   is defined that does that) and so affects screen readers only.
-*   If you do have such a class, but want to show this section to everyone,
-*   pass different properties with the `footnoteLabelProperties` option.
-* @property {Handlers | null | undefined} [handlers]
-*   Extra handlers for nodes (optional).
-* @property {Array<MdastNodes['type']> | null | undefined} [passThrough]
-*   List of custom mdast node types to pass through (keep) in hast (note that
-*   the node itself is passed, but eventual children are transformed)
-*   (optional).
-* @property {Handler | null | undefined} [unknownHandler]
-*   Handler for all unknown nodes (optional).
-*
-* @typedef State
-*   Info passed around.
-* @property {(node: MdastNodes) => Array<HastElementContent>} all
-*   Transform the children of an mdast parent to hast.
-* @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData
-*   Honor the `data` of `from`, and generate an element instead of `node`.
-* @property {Map<string, MdastDefinition>} definitionById
-*   Definitions by their identifier.
-* @property {Map<string, MdastFootnoteDefinition>} footnoteById
-*   Footnote definitions by their identifier.
-* @property {Map<string, number>} footnoteCounts
-*   Counts for how often the same footnote was called.
-* @property {Array<string>} footnoteOrder
-*   Identifiers of order when footnote calls first appear in tree order.
-* @property {Handlers} handlers
-*   Applied handlers.
-* @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one
-*   Transform an mdast node to hast.
-* @property {Options} options
-*   Configuration.
-* @property {(from: MdastNodes, node: HastNodes) => undefined} patch
-*   Copy a node’s positional info.
-* @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap
-*   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.
-*/
-var own = {}.hasOwnProperty;
-/** @type {Options} */
-var emptyOptions = {};
-/**
-* Create `state` from an mdast tree.
-*
-* @param {MdastNodes} tree
-*   mdast node to transform.
-* @param {Options | null | undefined} [options]
-*   Configuration (optional).
-* @returns {State}
-*   `state` function.
-*/
-function createState(tree, options) {
-	const settings = options || emptyOptions;
-	/** @type {Map<string, MdastDefinition>} */
-	const definitionById = /* @__PURE__ */ new Map();
-	/** @type {Map<string, MdastFootnoteDefinition>} */
-	const footnoteById = /* @__PURE__ */ new Map();
-	/** @type {State} */
-	const state = {
-		all,
-		applyData,
-		definitionById,
-		footnoteById,
-		footnoteCounts: /* @__PURE__ */ new Map(),
-		footnoteOrder: [],
-		handlers: {
-			...handlers,
-			...settings.handlers
-		},
-		one,
-		options: settings,
-		patch,
-		wrap
-	};
-	visit(tree, function(node) {
-		if (node.type === "definition" || node.type === "footnoteDefinition") {
-			const map = node.type === "definition" ? definitionById : footnoteById;
-			const id = String(node.identifier).toUpperCase();
-			if (!map.has(id)) map.set(id, node);
-		}
-	});
-	return state;
-	/**
-	* Transform an mdast node into a hast node.
-	*
-	* @param {MdastNodes} node
-	*   mdast node.
-	* @param {MdastParents | undefined} [parent]
-	*   Parent of `node`.
-	* @returns {Array<HastElementContent> | HastElementContent | undefined}
-	*   Resulting hast node.
-	*/
-	function one(node, parent) {
-		const type = node.type;
-		const handle = state.handlers[type];
-		if (own.call(state.handlers, type) && handle) return handle(state, node, parent);
-		if (state.options.passThrough && state.options.passThrough.includes(type)) {
-			if ("children" in node) {
-				const { children, ...shallow } = node;
-				const result = esm_default(shallow);
-				result.children = state.all(node);
-				return result;
-			}
-			return esm_default(node);
-		}
-		return (state.options.unknownHandler || defaultUnknownHandler)(state, node, parent);
-	}
-	/**
-	* Transform the children of an mdast node into hast nodes.
-	*
-	* @param {MdastNodes} parent
-	*   mdast node to compile
-	* @returns {Array<HastElementContent>}
-	*   Resulting hast nodes.
-	*/
-	function all(parent) {
-		/** @type {Array<HastElementContent>} */
-		const values = [];
-		if ("children" in parent) {
-			const nodes = parent.children;
-			let index = -1;
-			while (++index < nodes.length) {
-				const result = state.one(nodes[index], parent);
-				if (result) {
-					if (index && nodes[index - 1].type === "break") {
-						if (!Array.isArray(result) && result.type === "text") result.value = trimMarkdownSpaceStart(result.value);
-						if (!Array.isArray(result) && result.type === "element") {
-							const head = result.children[0];
-							if (head && head.type === "text") head.value = trimMarkdownSpaceStart(head.value);
-						}
-					}
-					if (Array.isArray(result)) values.push(...result);
-					else values.push(result);
-				}
-			}
-		}
-		return values;
-	}
-}
-/**
-* Copy a node’s positional info.
-*
-* @param {MdastNodes} from
-*   mdast node to copy from.
-* @param {HastNodes} to
-*   hast node to copy into.
-* @returns {undefined}
-*   Nothing.
-*/
-function patch(from, to) {
-	if (from.position) to.position = position(from);
-}
-/**
-* Honor the `data` of `from` and maybe generate an element instead of `to`.
-*
-* @template {HastNodes} Type
-*   Node type.
-* @param {MdastNodes} from
-*   mdast node to use data from.
-* @param {Type} to
-*   hast node to change.
-* @returns {HastElement | Type}
-*   Nothing.
-*/
-function applyData(from, to) {
-	/** @type {HastElement | Type} */
-	let result = to;
-	if (from && from.data) {
-		const hName = from.data.hName;
-		const hChildren = from.data.hChildren;
-		const hProperties = from.data.hProperties;
-		if (typeof hName === "string") if (result.type === "element") result.tagName = hName;
-		else result = {
-			type: "element",
-			tagName: hName,
-			properties: {},
-			children: "children" in result ? result.children : [result]
-		};
-		if (result.type === "element" && hProperties) Object.assign(result.properties, esm_default(hProperties));
-		if ("children" in result && result.children && hChildren !== null && hChildren !== void 0) result.children = hChildren;
-	}
-	return result;
-}
-/**
-* Transform an unknown node.
-*
-* @param {State} state
-*   Info passed around.
-* @param {MdastNodes} node
-*   Unknown mdast node.
-* @returns {HastElement | HastText}
-*   Resulting hast node.
-*/
-function defaultUnknownHandler(state, node) {
-	const data = node.data || {};
-	/** @type {HastElement | HastText} */
-	const result = "value" in node && !(own.call(data, "hProperties") || own.call(data, "hChildren")) ? {
-		type: "text",
-		value: node.value
-	} : {
-		type: "element",
-		tagName: "div",
-		properties: {},
-		children: state.all(node)
-	};
-	state.patch(node, result);
-	return state.applyData(node, result);
-}
-/**
-* Wrap `nodes` with line endings between each node.
-*
-* @template {HastRootContent} Type
-*   Node type.
-* @param {Array<Type>} nodes
-*   List of nodes to wrap.
-* @param {boolean | undefined} [loose=false]
-*   Whether to add line endings at start and end (default: `false`).
-* @returns {Array<HastText | Type>}
-*   Wrapped nodes.
-*/
-function wrap(nodes, loose) {
-	/** @type {Array<HastText | Type>} */
-	const result = [];
-	let index = -1;
-	if (loose) result.push({
-		type: "text",
-		value: "\n"
-	});
-	while (++index < nodes.length) {
-		if (index) result.push({
-			type: "text",
-			value: "\n"
-		});
-		result.push(nodes[index]);
-	}
-	if (loose && nodes.length > 0) result.push({
-		type: "text",
-		value: "\n"
-	});
-	return result;
-}
-/**
-* Trim spaces and tabs at the start of `value`.
-*
-* @param {string} value
-*   Value to trim.
-* @returns {string}
-*   Result.
-*/
-function trimMarkdownSpaceStart(value) {
-	let index = 0;
-	let code = value.charCodeAt(index);
-	while (code === 9 || code === 32) {
-		index++;
-		code = value.charCodeAt(index);
-	}
-	return value.slice(index);
-}
-//#endregion
-//#region node_modules/.pnpm/mdast-util-to-hast@13.2.1/node_modules/mdast-util-to-hast/lib/index.js
-/**
-* @import {Nodes as HastNodes} from 'hast'
-* @import {Nodes as MdastNodes} from 'mdast'
-* @import {Options} from './state.js'
-*/
-/**
-* Transform mdast to hast.
-*
-* ##### Notes
-*
-* ###### HTML
-*
-* Raw HTML is available in mdast as `html` nodes and can be embedded in hast
-* as semistandard `raw` nodes.
-* Most utilities ignore `raw` nodes but two notable ones don’t:
-*
-* *   `hast-util-to-html` also has an option `allowDangerousHtml` which will
-*     output the raw HTML.
-*     This is typically discouraged as noted by the option name but is useful
-*     if you completely trust authors
-* *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them
-*     into standard hast nodes (`element`, `text`, etc).
-*     This is a heavy task as it needs a full HTML parser, but it is the only
-*     way to support untrusted content
-*
-* ###### Footnotes
-*
-* Many options supported here relate to footnotes.
-* Footnotes are not specified by CommonMark, which we follow by default.
-* They are supported by GitHub, so footnotes can be enabled in markdown with
-* `mdast-util-gfm`.
-*
-* The options `footnoteBackLabel` and `footnoteLabel` define natural language
-* that explains footnotes, which is hidden for sighted users but shown to
-* assistive technology.
-* When your page is not in English, you must define translated values.
-*
-* Back references use ARIA attributes, but the section label itself uses a
-* heading that is hidden with an `sr-only` class.
-* To show it to sighted users, define different attributes in
-* `footnoteLabelProperties`.
-*
-* ###### Clobbering
-*
-* Footnotes introduces a problem, as it links footnote calls to footnote
-* definitions on the page through `id` attributes generated from user content,
-* which results in DOM clobbering.
-*
-* DOM clobbering is this:
-*
-* ```html
-* <p id=x></p>
-* <script>alert(x) // `x` now refers to the DOM `p#x` element<\/script>
-* ```
-*
-* Elements by their ID are made available by browsers on the `window` object,
-* which is a security risk.
-* Using a prefix solves this problem.
-*
-* More information on how to handle clobbering and the prefix is explained in
-* Example: headings (DOM clobbering) in `rehype-sanitize`.
-*
-* ###### Unknown nodes
-*
-* Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
-* The default behavior for unknown nodes is:
-*
-* *   when the node has a `value` (and doesn’t have `data.hName`,
-*     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`
-*     node
-* *   otherwise, create a `<div>` element (which could be changed with
-*     `data.hName`), with its children mapped from mdast to hast as well
-*
-* This behavior can be changed by passing an `unknownHandler`.
-*
-* @param {MdastNodes} tree
-*   mdast tree.
-* @param {Options | null | undefined} [options]
-*   Configuration (optional).
-* @returns {HastNodes}
-*   hast tree.
-*/
-function toHast(tree, options) {
-	const state = createState(tree, options);
-	const node = state.one(tree, void 0);
-	const foot = footer(state);
-	/** @type {HastNodes} */
-	const result = Array.isArray(node) ? {
-		type: "root",
-		children: node
-	} : node || {
-		type: "root",
-		children: []
-	};
-	if (foot) {
-		"children" in result;
-		result.children.push({
-			type: "text",
-			value: "\n"
-		}, foot);
-	}
-	return result;
-}
-//#endregion
-export { toHast as t };