@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/libs/mdast-util-to-hast.mjs

@@ -0,0 +1,1803 @@
+import { t as esm_default } from "./@ungap/structured-clone.mjs";
+import { a as position, i as pointStart, r as pointEnd } from "./hast-util-sanitize.mjs";
+import { t as ok } from "./devlop.mjs";
+import { f as asciiAlphanumeric } from "./mdast-util-from-markdown.mjs";
+import { r as visit } from "./mdast-util-gfm.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
+const tab = 9;
+const 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}
+*/
+const 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`.
+*/
+const own = {}.hasOwnProperty;
+/** @type {Options} */
+const 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) {
+		/* @__PURE__ */ ok("children" in result);
+		result.children.push({
+			type: "text",
+			value: "\n"
+		}, foot);
+	}
+	return result;
+}
+
+//#endregion
+export { toHast as t };