@mirrordown/core 0.0.0 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,2270 @@
+// src/escapes.ts
+const ASCII_PUNCTUATION = /^[!-/:-@[-`{-~]$/;
+const ENTITY = /^&(?:#\d+|#x[\da-f]+|[a-z][\da-z]*);/i;
+const MASK_BASE = 983040;
+const MASKED = /[\u{F0021}-\u{F007E}]/gu;
+/**
+* Indices of `value` whose character was backslash-escaped in `source`, where
+* `start`–`end` is the source range the text came from. Characters the parser
+* dropped (backslashes, container prefixes such as `> `, trailing spaces) are
+* skipped, and a character reference stands for the character it decodes to.
+*/
+const escapedIndices = (value, source, start, end) => {
+	const escaped = /* @__PURE__ */ new Set();
+	let j = start;
+	for (let i = 0; i < value.length && j < end; i++) {
+		const char = value.charAt(i);
+		let entity = null;
+		while (j < end && source[j] !== char) {
+			entity = source[j] === `&` ? ENTITY.exec(source.slice(j, end)) : null;
+			if (entity) break;
+			j++;
+		}
+		if (j >= end) break;
+		if (entity) {
+			j += entity[0].length;
+			continue;
+		}
+		let slashes = 0;
+		for (let k = j - 1; k >= start && source[k] === `\\`; k--) slashes++;
+		if (slashes % 2 === 1 && ASCII_PUNCTUATION.test(char)) escaped.add(i);
+		j++;
+	}
+	return escaped;
+};
+/** Replace the characters at `escaped` with stand-ins no delimiter matches. */
+const maskEscaped = (value, escaped) => {
+	if (escaped.size === 0) return value;
+	let out = ``;
+	for (let i = 0; i < value.length; i++) out += escaped.has(i) ? String.fromCodePoint(MASK_BASE + value.charCodeAt(i)) : value[i];
+	return out;
+};
+/** Restore characters replaced by {@link maskEscaped}. */
+const unmaskEscaped = (value) => value.replace(MASKED, (c) => String.fromCharCode(c.codePointAt(0) - MASK_BASE));
+/**
+* Mask escaped characters in every positioned `text` node of a unist tree, so
+* a delimiter scan skips them. Returns a function that restores them in every
+* node afterwards, including nodes the scan created from masked text.
+*/
+const maskTreeEscapes = (tree, source) => {
+	const walk = (node, visit) => {
+		visit(node);
+		node.children?.forEach((child) => walk(child, visit));
+	};
+	walk(tree, (node) => {
+		const start = node.position?.start.offset;
+		const end = node.position?.end.offset;
+		if (node.type !== `text` || typeof node.value !== `string`) return;
+		if (start === void 0 || end === void 0) return;
+		node.value = maskEscaped(node.value, escapedIndices(node.value, source, start, end));
+	});
+	return () => walk(tree, (node) => {
+		if (typeof node.value === `string`) node.value = unmaskEscaped(node.value);
+	});
+};
+// src/github-alerts/types.ts
+/** Maps every recognized alert keyword (lowercase) to its canonical {@link AlertType}. */
+const ALERT_ALIASES = {
+	note: "note",
+	tip: "tip",
+	important: "important",
+	warning: "warning",
+	caution: "caution",
+	abstract: "abstract",
+	summary: "abstract",
+	tldr: "abstract",
+	info: "info",
+	todo: "todo",
+	hint: "tip",
+	success: "success",
+	check: "success",
+	done: "success",
+	question: "question",
+	help: "question",
+	faq: "question",
+	attention: "warning",
+	failure: "failure",
+	fail: "failure",
+	missing: "failure",
+	danger: "danger",
+	error: "danger",
+	bug: "bug",
+	example: "example",
+	quote: "quote",
+	cite: "quote"
+};
+/** Default display title for each {@link AlertType}. */
+const DEFAULT_TITLE = {
+	note: "Note",
+	tip: "Tip",
+	important: "Important",
+	warning: "Warning",
+	caution: "Caution",
+	abstract: "Abstract",
+	info: "Info",
+	todo: "Todo",
+	success: "Success",
+	question: "Question",
+	failure: "Failure",
+	danger: "Danger",
+	bug: "Bug",
+	example: "Example",
+	quote: "Quote"
+};
+// src/github-alerts/icons.ts
+const icon = (path) => `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${path}</svg>`;
+/** Inline SVG icon markup for each {@link AlertType}. */
+const ICONS = {
+	note: icon("<path d=\"M12 20h9\"></path><path d=\"M16.376 3.622a1 1 0 0 1 3.002 3.002L7.368 18.635a2 2 0 0 1-.855.506l-2.872.838a.5.5 0 0 1-.62-.62l.838-2.872a2 2 0 0 1 .506-.854z\"></path>"),
+	tip: icon("<path d=\"M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5\"></path><path d=\"M9 18h6\"></path><path d=\"M10 22h4\"></path>"),
+	important: icon("<path d=\"M7.9 20A9 9 0 1 0 4 16.1L2 22z\"></path>"),
+	warning: icon("<path d=\"m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3\"></path><path d=\"M12 9v4\"></path><path d=\"M12 17h.01\"></path>"),
+	caution: icon("<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><path d=\"m4.9 4.9 14.2 14.2\"></path><path d=\"M12 8v4\"></path><path d=\"M12 16h.01\"></path>"),
+	abstract: icon("<rect width=\"8\" height=\"4\" x=\"8\" y=\"2\" rx=\"1\" ry=\"1\"></rect><path d=\"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2\"></path><path d=\"M12 11h4\"></path><path d=\"M12 16h4\"></path><path d=\"M8 11h.01\"></path><path d=\"M8 16h.01\"></path>"),
+	info: icon("<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><path d=\"M12 16v-4\"></path><path d=\"M12 8h.01\"></path>"),
+	todo: icon("<path d=\"M8 6h13\"></path><path d=\"M8 12h13\"></path><path d=\"M8 18h13\"></path><path d=\"M3 6h.01\"></path><path d=\"M3 12h.01\"></path><path d=\"M3 18h.01\"></path>"),
+	success: icon("<path d=\"M22 11.08V12a10 10 0 1 1-5.93-9.14\"></path><path d=\"m9 11 3 3L22 4\"></path>"),
+	question: icon("<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><path d=\"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3\"></path><path d=\"M12 17h.01\"></path>"),
+	failure: icon("<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><path d=\"m15 9-6 6\"></path><path d=\"m9 9 6 6\"></path>"),
+	danger: icon("<path d=\"M13 2 3 14h9l-1 8 10-12h-9l1-8z\"></path>"),
+	bug: icon("<path d=\"m8 2 1.88 1.88\"></path><path d=\"M14.12 3.88 16 2\"></path><path d=\"M9 7.13v-1a3.003 3.003 0 1 1 6 0v1\"></path><path d=\"M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6\"></path><path d=\"M12 20v-9\"></path><path d=\"M6.53 9C4.6 8.8 3 7.1 3 5\"></path><path d=\"M6 13H2\"></path><path d=\"M3 21c0-2.1 1.7-3.9 3.8-4\"></path><path d=\"M20.97 5c0 2.1-1.6 3.8-3.5 4\"></path><path d=\"M22 13h-4\"></path><path d=\"M17.2 17c2.1.1 3.8 1.9 3.8 4\"></path>"),
+	example: icon("<path d=\"M8 6h13\"></path><path d=\"M8 12h13\"></path><path d=\"M8 18h13\"></path><path d=\"M3 6 4 5l1 1-1 1z\"></path><path d=\"M3 12 4 11l1 1-1 1z\"></path><path d=\"M3 18 4 17l1 1-1 1z\"></path>"),
+	quote: icon("<path d=\"M3 21c3 0 7-1 7-8V5c0-1.25-.756-2.017-2-2H4c-1.25 0-2 .75-2 1.972V11c0 1.25.75 2 2 2 1 0 1 0 1 1v1c0 1-1 2-2 2s-1 .008-1 1.031V20c0 1 0 1 1 1z\"></path><path d=\"M15 21c3 0 7-1 7-8V5c0-1.25-.757-2.017-2-2h-4c-1.25 0-2 .75-2 1.972V11c0 1.25.75 2 2 2h.75c0 2.25.25 4-2.75 4v3c0 1 0 1 1 1z\"></path>")
+};
+// src/github-alerts/index.ts
+const MARKER_RE = /^\[!([^\]]+)\]([+-])?/;
+/** Whether a source line opens an alert (`> [!NOTE]`), after its `>` markers and indentation, whether or not the alerts plugin reads it: a block that takes the quote after it as more of its content (a step body) leaves an alert be. */
+const isAlertMarkerLine = (line) => MARKER_RE.test(line.replace(/^[ 	>]*/, ``));
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+/** Resolve alert keywords, titles and icons the same way in every engine. */
+const createAlertResolver = (options = {}) => {
+	const { types: extraTypes = {}, titles = {}, matchCaseInsensitive = true, icons = true, containerClass = `markdown-alert` } = options;
+	const aliasMap = {
+		...ALERT_ALIASES,
+		...extraTypes
+	};
+	const customTitles = titles;
+	const isAlertType = (type) => type in DEFAULT_TITLE;
+	return {
+		resolve: (keyword) => aliasMap[matchCaseInsensitive ? keyword.toLowerCase() : keyword],
+		titleFor: (type) => customTitles[type] ?? (isAlertType(type) ? DEFAULT_TITLE[type] : void 0) ?? capitalize(type),
+		iconFor: (type) => icons && isAlertType(type) ? ICONS[type] : ``,
+		containerClass
+	};
+};
+/** Plain text of inline content: text, inline code and image alt count; raw HTML does not. */
+const plainText = (nodes) => nodes.map((n) => n.type === `text` || n.type === `inlineCode` ? n.value ?? `` : n.type === `image` ? n.alt ?? `` : n.children ? plainText(n.children) : ``).join(``);
+const withValue = (node, value) => ({
+	...node,
+	value
+});
+/**
+* Split an alert's first paragraph (an mdast `paragraph`'s children) into its marker, title and body, or return `null` when it does not open with a `[!KEYWORD]` marker in plain text. The first line is the marker plus an optional title; everything after the first line break — a newline inside a text node (soft) or a `break` node (hard) — is the body. Nothing is dropped. Text nodes are copied; other nodes are reused as they are.
+*/
+const splitAlertParagraph = (children) => {
+	const [first, ...rest] = children;
+	if (first?.type !== `text` || first.value === void 0) return null;
+	const opening = first.value.trimStart();
+	const match = MARKER_RE.exec(opening);
+	if (!match) return null;
+	const [marker, keyword = ``, fold] = match;
+	const line = [];
+	const body = [];
+	for (const child of [withValue(first, opening.slice(marker.length)), ...rest]) if (body.length > 0 || line.at(-1)?.type === `break`) body.push(child);
+	else if (child.type === `text` && child.value?.includes(`\n`)) {
+		const at = child.value.indexOf(`\n`);
+		line.push(withValue(child, child.value.slice(0, at)));
+		body.push(withValue(child, child.value.slice(at + 1)));
+	} else line.push(child);
+	if (line.at(-1)?.type === `break`) line.pop();
+	const titleNodes = line.map((n, i) => n.type !== `text` ? n : withValue(n, i === 0 && i === line.length - 1 ? (n.value ?? ``).trim() : i === 0 ? (n.value ?? ``).trimStart() : i === line.length - 1 ? (n.value ?? ``).trimEnd() : n.value ?? ``)).filter((n) => n.type !== `text` || n.value !== ``);
+	const lastTitle = titleNodes.at(-1);
+	if (lastTitle?.type === `text`) titleNodes[titleNodes.length - 1] = withValue(lastTitle, (lastTitle.value ?? ``).trimEnd());
+	return {
+		keyword,
+		fold: fold === `+` || fold === `-` ? fold : void 0,
+		titleNodes,
+		titleText: plainText(titleNodes).trim(),
+		bodyNodes: body.filter((n) => n.type !== `text` || n.value !== ``)
+	};
+};
+// src/spans.ts
+/** Wrap a scan with built-node tracking and source-based escape masking. */
+const createSpanTransform = (nodes, scan) => {
+	const built = /* @__PURE__ */ new WeakSet();
+	const contents = /* @__PURE__ */ new WeakMap();
+	const tracked = {
+		text: (value) => {
+			const node = nodes.text(value);
+			built.add(node);
+			return node;
+		},
+		wrap: (children) => {
+			const node = nodes.wrap(children);
+			built.add(node);
+			contents.set(node, children);
+			return node;
+		}
+	};
+	const transform = (children, parentType = ``) => scan(children, parentType, tracked);
+	const restore = (list) => {
+		for (const node of list) {
+			if (!built.has(node)) continue;
+			if (node.type === `text` && node.value !== void 0) node.value = unmaskEscaped(node.value);
+			else restore(contents.get(node) ?? []);
+		}
+	};
+	const withSource = (children, parentType, source) => {
+		const masked = children.map((node) => {
+			const start = node.position?.start.offset;
+			const end = node.position?.end.offset;
+			if (node.type !== `text` || node.value === void 0 || start === void 0 || end === void 0) return node;
+			const escaped = escapedIndices(node.value, source, start, end);
+			return escaped.size === 0 ? node : tracked.text(maskEscaped(node.value, escaped));
+		});
+		const next = transform(masked, parentType);
+		if (next === masked) return void 0;
+		restore(next);
+		return [...next];
+	};
+	return Object.assign(transform, {
+		built: (node) => built.has(node),
+		withSource
+	});
+};
+// src/delimited.ts
+const INLINE_PARENTS = /* @__PURE__ */ new Set([
+	`delete`,
+	`emphasis`,
+	`insert`,
+	`link`,
+	`linkReference`,
+	`mark`,
+	`spoiler`,
+	`spoilerContent`,
+	`strong`,
+	`subscript`,
+	`superscript`
+]);
+const WHITESPACE$3 = /^[\t\n\v\f\r \u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]$/u;
+const PUNCTUATION$1 = /^[\p{P}\p{S}]$/u;
+const classify$1 = (char) => WHITESPACE$3.test(char) ? `space` : PUNCTUATION$1.test(char) ? `punct` : `other`;
+/**
+* markdown-it's `balance_pairs` for a single marker. Every delimiter has `length: 0`, as in markdown-it-mark, so the emphasis "rule of 3" never applies.
+*/
+const balancePairs = (delimiters) => {
+	const jumps = [];
+	const openersBottom = [
+		-1,
+		-1,
+		-1,
+		-1,
+		-1,
+		-1
+	];
+	let headerIdx = 0;
+	let lastItem = -2;
+	delimiters.forEach((closer, closerIdx) => {
+		jumps.push(0);
+		if (lastItem !== closer.item - 1) headerIdx = closerIdx;
+		lastItem = closer.item;
+		if (!closer.close) return;
+		const bottom = closer.open ? 3 : 0;
+		const minOpenerIdx = openersBottom[bottom] ?? -1;
+		let openerIdx = headerIdx - (jumps[headerIdx] ?? 0) - 1;
+		let newMinOpenerIdx = openerIdx;
+		for (; openerIdx > minOpenerIdx; openerIdx -= (jumps[openerIdx] ?? 0) + 1) {
+			const opener = delimiters[openerIdx];
+			if (!opener?.open || opener.end >= 0) continue;
+			const lastJump = openerIdx > 0 && delimiters[openerIdx - 1]?.open === false ? (jumps[openerIdx - 1] ?? 0) + 1 : 0;
+			jumps[closerIdx] = closerIdx - openerIdx + lastJump;
+			jumps[openerIdx] = lastJump;
+			closer.open = false;
+			opener.end = closerIdx;
+			opener.close = false;
+			newMinOpenerIdx = -1;
+			lastItem = -2;
+			break;
+		}
+		if (newMinOpenerIdx !== -1) openersBottom[bottom] = newMinOpenerIdx;
+	});
+};
+/** Build the delimiter scan for one marker: `=` (mark), `+` (ins), `-` (del) or `|` (spoiler). */
+const createDelimitedTransform = (marker, nodes) => createSpanTransform(nodes, (children, parentType, { text, wrap }) => {
+	const edge = INLINE_PARENTS.has(parentType) ? `punct` : `space`;
+	const beside = (node, side) => {
+		if (!node) return edge;
+		if (node.type === `text` && node.value) return classify$1(side === `before` ? node.value.slice(-1) : node.value.charAt(0));
+		return node.type === `break` ? `space` : `punct`;
+	};
+	const items = [];
+	const delimiters = [];
+	children.forEach((child, index) => {
+		const value = child.type === `text` ? child.value : void 0;
+		if (value === void 0) {
+			items.push({
+				kind: `node`,
+				node: child
+			});
+			return;
+		}
+		let pending = ``;
+		const flush = () => {
+			if (pending) items.push({
+				kind: `text`,
+				value: pending
+			});
+			pending = ``;
+		};
+		let i = 0;
+		while (i < value.length) {
+			let end = i;
+			while (value.charAt(end) === marker) end++;
+			if (end - i < 2) {
+				pending += value.slice(i, Math.max(end, i + 1));
+				i = Math.max(end, i + 1);
+				continue;
+			}
+			const last = i > 0 ? classify$1(value.charAt(i - 1)) : beside(children[index - 1], `before`);
+			const next = end < value.length ? classify$1(value.charAt(end)) : beside(children[index + 1], `after`);
+			const open = next !== `space` && (next !== `punct` || last !== `other`);
+			const close = last !== `space` && (last !== `punct` || next !== `other`);
+			flush();
+			let length = end - i;
+			if (length % 2) {
+				items.push({
+					kind: `text`,
+					value: marker
+				});
+				length--;
+			}
+			for (let pair = 0; pair < length; pair += 2) if (open || close) {
+				delimiters.push({
+					open,
+					close,
+					end: -1,
+					item: items.length
+				});
+				items.push({ kind: `delimiter` });
+			} else items.push({
+				kind: `text`,
+				value: marker + marker
+			});
+			i = end;
+		}
+		flush();
+	});
+	balancePairs(delimiters);
+	if (!delimiters.some(({ end }) => end >= 0)) return children;
+	const lone = [];
+	for (const delimiter of delimiters) {
+		const closer = delimiters[delimiter.end];
+		if (!closer) continue;
+		items[delimiter.item] = { kind: `opening` };
+		items[closer.item] = { kind: `closing` };
+		const previous = items[closer.item - 1];
+		if (previous?.kind === `text` && previous.value === marker) lone.push(closer.item - 1);
+	}
+	for (const i of lone.reverse()) {
+		let j = i + 1;
+		while (items[j]?.kind === `closing`) j++;
+		j--;
+		const moved = items[i];
+		const target = items[j];
+		if (i !== j && moved && target) {
+			items[i] = target;
+			items[j] = moved;
+		}
+	}
+	const root = [];
+	const stack = [root];
+	let buffer = ``;
+	const append = (node) => {
+		(stack.at(-1) ?? root).push(node);
+	};
+	const flushText = () => {
+		if (!buffer) return;
+		append(text(buffer));
+		buffer = ``;
+	};
+	for (const item of items) if (item.kind === `text`) buffer += item.value;
+	else if (item.kind === `delimiter`) buffer += marker + marker;
+	else if (item.kind === `node`) {
+		flushText();
+		append(item.node);
+	} else if (item.kind === `opening`) {
+		flushText();
+		stack.push([]);
+	} else {
+		flushText();
+		append(wrap(stack.pop() ?? []));
+	}
+	flushText();
+	return root;
+});
+// src/kbd.ts
+const isChar = (unit, char) => unit !== void 0 && `char` in unit && unit.char === char;
+/**
+* The index of the `]]` that closes the `[[` at `start`, or -1. This mirrors markdown-it-kbd's loop, which looks at each character with the one after it, starting from the opener's second `[`, and skips the second character of every pair it consumes.
+*/
+const findClose = (units, start) => {
+	let depth = 1;
+	let skipNext = false;
+	for (let i = start + 1; i < units.length; i++) {
+		if (skipNext) {
+			skipNext = false;
+			continue;
+		}
+		const unit = units[i];
+		const next = units[i + 1];
+		if (isChar(unit, `]`) && isChar(next, `]`)) {
+			depth--;
+			if (depth === 0) return i;
+			skipNext = true;
+		} else if (isChar(unit, `[`) && isChar(next, `[`)) {
+			depth++;
+			skipNext = true;
+		} else if (isChar(unit, `\n`) || unit && `node` in unit && unit.node.type === `break`) return -1;
+	}
+	return -1;
+};
+/** Build the `[[key]]` scan. */
+const createKbdTransform = (nodes) => createSpanTransform(nodes, (children, _parentType, { text, wrap }) => {
+	const units = children.flatMap((child) => {
+		const value = child.type === `text` ? child.value : void 0;
+		return value === void 0 ? [{ node: child }] : Array.from(value, (char) => ({ char }));
+	});
+	const scan = (list) => {
+		const out = [];
+		let keyed = false;
+		let buffer = ``;
+		const flushText = () => {
+			if (buffer) out.push(text(buffer));
+			buffer = ``;
+		};
+		for (let i = 0; i < list.length;) {
+			const unit = list[i];
+			if (isChar(unit, `[`) && isChar(list[i + 1], `[`)) {
+				const end = findClose(list, i);
+				if (end >= 0) {
+					keyed = true;
+					flushText();
+					out.push(wrap(scan(list.slice(i + 2, end)).nodes));
+					i = end + 2;
+					continue;
+				}
+			}
+			if (unit && `char` in unit) buffer += unit.char;
+			else if (unit) {
+				flushText();
+				out.push(unit.node);
+			}
+			i++;
+		}
+		flushText();
+		return {
+			nodes: out,
+			keyed
+		};
+	};
+	const { nodes: result, keyed } = scan(units);
+	return keyed ? result : children;
+});
+// src/scripts.ts
+/** The marker characters, and the micromark token types each produces. */
+const SCRIPTS = {
+	"~": {
+		code: 126,
+		type: `subscript`
+	},
+	"^": {
+		code: 94,
+		type: `superscript`
+	}
+};
+const tokenType = (type) => type;
+const temporary = (type) => tokenType(`${type}SequenceTemporary`);
+const scriptOf = (tokenType) => Object.values(SCRIPTS).find(({ type }) => temporary(type) === tokenType);
+const PUNCTUATION = /\p{P}|\p{S}/u;
+const WHITESPACE$2 = /\s/;
+const classify = (code) => code === null || code < 0 || code === 32 || WHITESPACE$2.test(String.fromCharCode(code)) ? 1 : PUNCTUATION.test(String.fromCharCode(code)) ? 2 : void 0;
+const splice = (list, start, remove, items) => {
+	list.splice(start, remove);
+	for (let i = 0; i < items.length; i += 1e4) list.splice(start + i, 0, ...items.slice(i, i + 1e4));
+};
+const resolveAll = (constructs, events, context) => {
+	const called = [];
+	let result = events;
+	for (const { resolveAll: resolve } of constructs) if (resolve && !called.includes(resolve)) {
+		result = resolve(result, context);
+		called.push(resolve);
+	}
+	return result;
+};
+const resolveScripts = (events, context) => {
+	for (let index = 0; index < events.length; index++) {
+		const [kind, closer] = events.at(index) ?? [];
+		const script = closer && scriptOf(closer.type);
+		if (kind !== `enter` || !closer || !script || !closer._close) continue;
+		for (let open = index - 1; open >= 0; open--) {
+			const [openKind, opener] = events.at(open) ?? [];
+			if (openKind !== `exit` || !opener || opener.type !== closer.type || !opener._open) continue;
+			opener.type = tokenType(`${script.type}Sequence`);
+			closer.type = tokenType(`${script.type}Sequence`);
+			const span = {
+				type: tokenType(script.type),
+				start: { ...opener.start },
+				end: { ...closer.end }
+			};
+			const text = {
+				type: tokenType(`${script.type}Text`),
+				start: { ...opener.end },
+				end: { ...closer.start }
+			};
+			const next = [
+				[
+					`enter`,
+					span,
+					context
+				],
+				[
+					`enter`,
+					opener,
+					context
+				],
+				[
+					`exit`,
+					opener,
+					context
+				],
+				[
+					`enter`,
+					text,
+					context
+				],
+				...resolveAll(context.parser.constructs.insideSpan.null ?? [], events.slice(open + 1, index), context),
+				[
+					`exit`,
+					text,
+					context
+				],
+				[
+					`enter`,
+					closer,
+					context
+				],
+				[
+					`exit`,
+					closer,
+					context
+				],
+				[
+					`exit`,
+					span,
+					context
+				]
+			];
+			splice(events, open - 1, index - open + 3, next);
+			index = open + next.length - 2;
+			break;
+		}
+	}
+	for (const [, token] of events) if (scriptOf(token.type)) token.type = `data`;
+	return events;
+};
+function tokenize(effects, ok, nok) {
+	const { previous, events } = this;
+	return (start) => {
+		const script = Object.values(SCRIPTS).find((s) => s.code === start);
+		if (!script) return nok(start);
+		if (previous === script.code && events.at(-1)?.[1].type !== `characterEscape`) return nok(start);
+		effects.enter(temporary(script.type));
+		effects.consume(start);
+		return (after) => {
+			if (after === script.code) return nok(after);
+			const token = effects.exit(temporary(script.type));
+			const before = classify(previous);
+			const next = classify(after);
+			token._open = !next || next === 2 && Boolean(before);
+			token._close = !before || before === 2 && Boolean(next);
+			return ok(after);
+		};
+	};
+}
+/**
+* The micromark syntax extension for one of the two markers: `~` (subscript, `subscript` tokens) or `^` (superscript, `superscript` tokens). The constructs of both markers resolve together.
+*/
+const scriptSyntax = (marker) => {
+	const construct = {
+		name: SCRIPTS[marker].type,
+		tokenize,
+		resolveAll: resolveScripts
+	};
+	return {
+		text: { [SCRIPTS[marker].code]: construct },
+		insideSpan: { null: [construct] }
+	};
+};
+// src/cut-attributes.ts
+/** Paragraphs recognition rebuilt from lines, as it does where a tab or step header lazily continued them. */
+const rebuiltParagraphs = /* @__PURE__ */ new WeakSet();
+/** Joins `added` into `properties`: classes accumulate, other attributes replace. */
+const mergeProperties = (properties, added) => {
+	const merged = { ...properties };
+	for (const [key, value] of Object.entries(added)) {
+		const existing = merged[key];
+		merged[key] = key === "className" && Array.isArray(existing) && Array.isArray(value) ? [...existing, ...value] : value;
+	}
+	return merged;
+};
+const listLoose = (list) => list?.type !== "list" || Boolean(list.spread) || list.children.some((item) => item.spread ?? item.children.length > 1);
+/**
+* Places the attribute block now ending each paragraph recognition rebuilt (one a header was cut from), as the parser places one: a block on a line of its own goes on the block it's written after, at the level its `>` markers and indentation put it (the paragraph, its list item in a tight list, or the outermost blockquote or list item it's written outside of, a list item giving its list); a block after text goes on the paragraph, or its list item from the item's first paragraph.
+*/
+const placeCutAttributes = (root, sourceLines, read) => {
+	const parents = /* @__PURE__ */ new Map();
+	const cut = [];
+	const items = [];
+	const walk = (node) => {
+		if (node.type === "paragraph" && rebuiltParagraphs.has(node)) cut.push(node);
+		const data = node.data;
+		if (typeof data === "object" && data !== null && "attrsRole" in data && data.attrsRole === "containerItem" && "attrsTitle" in data && Array.isArray(data.attrsTitle)) items.push(node);
+		if (!("children" in node)) return;
+		for (const child of node.children) {
+			parents.set(child, node);
+			walk(child);
+		}
+	};
+	walk(root);
+	for (const para of cut) {
+		const children = para.children;
+		const last = children.at(-1);
+		if (last?.type !== "text") continue;
+		const value = last.value.trimEnd();
+		const lineStart = value.lastIndexOf("\n");
+		const line = value.slice(lineStart + 1);
+		const open = line.lastIndexOf("{");
+		if (open === -1) continue;
+		const properties = read(line.slice(open));
+		if (!properties) continue;
+		const before = line.slice(0, open);
+		const ownLine = before.trim() === "" && (lineStart !== -1 || children.at(-2)?.type === "break");
+		if (before === "" && !ownLine) continue;
+		const ancestors = [];
+		for (let p = parents.get(para); p; p = parents.get(p)) ancestors.unshift(p);
+		const parent = ancestors.at(-1);
+		let target = para;
+		if (ownLine) {
+			const end = last.position?.end;
+			const written = end ? sourceLines[end.line - 1] ?? "" : "";
+			const prefix = /^[ \t>]*/.exec(written)?.[0] ?? "";
+			const markers = prefix.split(">").length - 1;
+			const outside = end ? ancestors.findIndex((ancestor) => {
+				const start = ancestor.position?.start;
+				if (ancestor.type === "blockquote" && start) {
+					const own = (sourceLines[start.line - 1] ?? "").slice(0, start.column - 1);
+					return markers < own.split(">").length;
+				}
+				const first = ancestor.type === "listItem" ? ancestor.children[0]?.position?.start : void 0;
+				return first !== void 0 && prefix.length < first.column - 1;
+			}) : -1;
+			const container = ancestors[outside];
+			if (container) target = container.type === "listItem" ? ancestors[outside - 1] ?? container : container;
+			else if (parent?.type === "listItem" && !listLoose(ancestors.at(-2))) target = parent;
+		} else if (parent?.type === "listItem" && parent.children[0] === para) target = parent;
+		const data = target.data;
+		target.data = {
+			...data,
+			hProperties: mergeProperties(data?.hProperties, properties)
+		};
+		const kept = ownLine ? value.slice(0, Math.max(lineStart, 0)) : value.slice(0, lineStart + 1) + before;
+		if (kept.trimEnd() === "") children.pop();
+		else last.value = kept.trimEnd();
+	}
+	for (const item of items) {
+		const title = item.data.attrsTitle;
+		const last = title.at(-1);
+		if (last?.type !== "text") continue;
+		const value = last.value.trimEnd();
+		const open = value.lastIndexOf("{");
+		if (open === -1) continue;
+		const properties = read(value.slice(open));
+		if (!properties) continue;
+		item.data.hProperties = mergeProperties(item.data.hProperties, properties);
+		last.value = value.slice(0, open).trimEnd();
+		if (last.value === "" && title.length > 1) title.pop();
+	}
+};
+// src/lazy.ts
+/** The `>` markers a source line starts with. */
+const markerCount = (line) => (/^[ \t>]*/.exec(line)?.[0] ?? "").split(">").length - 1;
+/** The `>` markers of a blockquote's own lines: those before it on its first line, and its own (that line can open nested blockquotes too). */
+const blockquoteMarkers = (bq, sourceLines) => {
+	const start = bq.position?.start;
+	if (!start) return void 0;
+	return markerCount((sourceLines[start.line - 1] ?? "").slice(0, start.column - 1)) + 1;
+};
+/**
+* A paragraph's phrasing content split into its lines: text at each line ending, and after a hard break, which stays at the end of its line. With the source, the text on each line keeps its place in it, as remark would give it: from after the line's container prefix to its last non-space character.
+*/
+const paraToLines = (para, sourceLines) => {
+	const lines = [[]];
+	for (const child of para.children) if (child.type === "break") {
+		lines.at(-1)?.push(child);
+		lines.push([]);
+	} else if (child.type === "text") {
+		const parts = child.value.split("\n");
+		for (const [p, part] of parts.entries()) {
+			if (p > 0) lines.push([]);
+			if (part === "") continue;
+			const text = {
+				type: "text",
+				value: part
+			};
+			const position = child.position;
+			if (position) {
+				const line = position.start.line + p;
+				const source = sourceLines?.[line - 1];
+				const start = p === 0 ? position.start : source === void 0 ? void 0 : {
+					line,
+					column: (/^[ \t>]*/.exec(source)?.[0].length ?? 0) + 1
+				};
+				const end = p === parts.length - 1 ? position.end : source === void 0 ? void 0 : {
+					line,
+					column: source.trimEnd().length + 1
+				};
+				if (start && end) text.position = {
+					start,
+					end
+				};
+			}
+			lines.at(-1)?.push(text);
+		}
+	} else lines.at(-1)?.push(child);
+	return lines;
+};
+/** The attributes a paragraph carries, which a parser that reads attribute blocks before recognition (Sätteri) read off its end: they belong to its last line. */
+const paragraphProperties = (para) => {
+	return para.data?.hProperties;
+};
+/** Appends `node` to `children`, merging text into the text before it, as remark keeps a run of text in one node. */
+const pushPhrasing = (children, node) => {
+	const last = children.at(-1);
+	if (node.type !== "text" || last?.type !== "text") {
+		children.push(node);
+		return;
+	}
+	const start = last.position?.start ?? (last.value.trim() === "" ? node.position?.start : void 0);
+	const end = node.position?.end ?? last.position?.end;
+	const merged = {
+		type: "text",
+		value: last.value + node.value
+	};
+	if (start && end) merged.position = {
+		start,
+		end
+	};
+	children[children.length - 1] = merged;
+};
+/** A paragraph from lines of phrasing content, or `null` for none. Lines join with a line ending, except after a hard break, which is one. */
+const linesToParagraph = (lines) => {
+	const children = [];
+	for (const [i, line] of lines.entries()) {
+		if (i > 0 && lines[i - 1]?.at(-1)?.type !== "break") pushPhrasing(children, {
+			type: "text",
+			value: "\n"
+		});
+		for (const node of line) pushPhrasing(children, node);
+	}
+	if (children.length === 0) return null;
+	const para = {
+		type: "paragraph",
+		children
+	};
+	const start = children[0]?.position?.start;
+	const end = children.at(-1)?.position?.end;
+	if (start && end) para.position = {
+		start,
+		end
+	};
+	rebuiltParagraphs.add(para);
+	return para;
+};
+/**
+* The blocks lazily continued lines stand for, from their markers relative to the body they belong to (`level` deep): as such lines go on CommonMark only nests deeper, so a line with more markers opens blockquotes and a new paragraph, and a line with fewer continues the paragraph it follows.
+*/
+const rebuildLazyLines = (lines, level) => {
+	const deeper = lines.findIndex(({ markers }) => markers > level);
+	const own = deeper === -1 ? lines : lines.slice(0, deeper);
+	const para = linesToParagraph(own.map(({ segs }) => segs));
+	const blocks = para ? [para] : [];
+	if (deeper !== -1) {
+		const quote = {
+			type: "blockquote",
+			children: rebuildLazyLines(lines.slice(deeper), level + 1)
+		};
+		blocks.push(quote);
+	}
+	return blocks;
+};
+/** Blocks whose lines carry one more `>` marker than the block around them: a blockquote (or an alert, Sätteri's node for one) and a tab panel or step body. */
+const MARKED_BLOCKS = /* @__PURE__ */ new Set([
+	`blockquote`,
+	`alert`,
+	`tabsItem`,
+	`stepsItem`
+]);
+/** Blocks a line can lazily continue into by its indentation rather than its markers: a list item or a definition. */
+const INDENTED_BLOCKS = /* @__PURE__ */ new Set([
+	`listItem`,
+	`defListDescription`,
+	`descriptionDetails`
+]);
+/**
+* A paragraph split before its first line (after its first) that `opens` a group, written at the paragraph's level (`quotes` `>` markers), as markdown-it's block rules interrupt a paragraph; `null` when there's none. Attributes ending the paragraph go with the part they end.
+*/
+const splitAtOpeningLine = (para, sourceLines, quotes, opens) => {
+	const start = para.position?.start.line;
+	if (start === void 0) return null;
+	const lines = paraToLines(para, sourceLines);
+	const at = lines.findIndex((line, index) => {
+		const first = line[0];
+		return index > 0 && first?.type === `text` && opens(first.value) && markerCount(sourceLines[start - 1 + index] ?? ``) === quotes;
+	});
+	if (at === -1) return null;
+	const head = linesToParagraph(lines.slice(0, at));
+	const tail = linesToParagraph(lines.slice(at));
+	if (!head || !tail) return null;
+	if (para.data) tail.data = para.data;
+	return [head, tail];
+};
+const lastParagraph = (node) => {
+	const last = node?.children?.at(-1);
+	if (!last) return void 0;
+	if (last.type === `paragraph`) return last;
+	return lastParagraph(last);
+};
+/**
+* End each group of `listType` (tab groups or steps) where its last panel's `>` markers stop, as markdown-it reads a panel: a line CommonMark lazily continued into the panel's last paragraph, written with fewer markers than the panel's own lines, starts a paragraph after the group, with the lines after it. Groups nested in a panel are ended first, so a line that leaves an outer panel too moves on past its group. The paragraph's attributes (Sätteri reads them off its end) go with its last line.
+*/
+const endGroupsAtMarkers = (root, sourceLines, listType) => {
+	const visit = (node, quotes) => {
+		const children = node.children;
+		if (!children) return;
+		for (let i = 0; i < children.length; i++) {
+			const child = children[i];
+			visit(child, quotes + (MARKED_BLOCKS.has(child.type) ? 1 : 0));
+			if (child.type !== listType) continue;
+			const para = lastParagraph(child.children?.at(-1));
+			const start = para?.position?.start.line;
+			if (!para || start === void 0) continue;
+			const lines = paraToLines(para, sourceLines);
+			const outside = lines.findIndex((_, index) => index > 0 && markerCount(sourceLines[start - 1 + index] ?? ``) < quotes + 1);
+			if (outside === -1) continue;
+			const kept = linesToParagraph(lines.slice(0, outside));
+			const moved = linesToParagraph(lines.slice(outside));
+			if (!kept || !moved) continue;
+			para.children = kept.children;
+			const data = para.data;
+			if (data?.hProperties) {
+				const { hProperties, ...rest } = data;
+				moved.data = { hProperties };
+				para.data = rest;
+			}
+			children.splice(i + 1, 0, moved);
+		}
+	};
+	visit(root, 0);
+};
+// src/line-containers.ts
+/**
+* How many of `containers`, outermost first, a line is written in. Tabs count as one column.
+*/
+const containersKept = (line, containers) => {
+	const prefix = /^[ \t>]*/.exec(line)?.[0] ?? ``;
+	const markers = prefix.split(`>`).length - 1;
+	let kept = 0;
+	for (const container of containers) {
+		if (container.kind === `quote` ? markers < container.markers : prefix.length < container.column) break;
+		kept++;
+	}
+	return kept;
+};
+/**
+* The columns the content of the list items opened on a line starts at, in the order they open, as CommonMark reads a list marker: up to four spaces after it belong to the marker, more start indented content one column after.
+*/
+const itemColumns = (line) => {
+	const columns = [];
+	let pos = 0;
+	for (;;) {
+		while (line[pos] === ` ` || line[pos] === `\t`) pos++;
+		if (line[pos] === `>`) {
+			pos++;
+			continue;
+		}
+		const marker = /^(?:[-+*]|\d{1,9}[.)])(?=[ \t]|$)/.exec(line.slice(pos));
+		if (!marker) return columns;
+		const end = pos + marker[0].length;
+		let spaces = 0;
+		while (line[end + spaces] === ` ` || line[end + spaces] === `\t`) spaces++;
+		const column = end + spaces === line.length || spaces > 4 ? end + 1 : end + spaces;
+		columns.push(column);
+		if (spaces > 4) return columns;
+		pos = column;
+	}
+};
+// src/caption.ts
+/** The class of the `<figure>` a caption wraps its block in. */
+const CAPTION_CLASS = "markdown-caption";
+/** Whether a source line is a caption line: `~:`, whitespace and the caption's first word after its `>` markers and indentation. An escaped `\~:` isn't one, nor is a marker with nothing after it. */
+const isCaptionLine = (line) => /^~:[ \t]+\S/.test(line.replace(/^[ \t>]*/, ``));
+/** Whether text starts with a caption marker, as a parser gives a caption line's text (inline markdown may follow in other nodes). */
+const startsCaption = (text) => /^~:(?:[ \t]|$)/.test(text);
+/** The text after a caption marker. */
+const stripCaptionMarker = (text) => text.replace(/^~:[ \t]*/, ``);
+/**
+* Blocks a caption doesn't attach to, by mdast (and custom node) type: a caption after them stays text. Headings, thematic breaks, raw HTML, definitions and front matter, another caption's figure, and the parts of containers that aren't blocks of their own (titles, labels, terms).
+*/
+const UNCAPTIONED = /* @__PURE__ */ new Set([
+	`heading`,
+	`thematicBreak`,
+	`html`,
+	`definition`,
+	`footnoteDefinition`,
+	`yaml`,
+	`toml`,
+	`figure`,
+	`alertTitle`,
+	`stepsTitle`,
+	`tabsLabel`,
+	`tabsLabels`,
+	`tabsInput`,
+	`defListTerm`,
+	`descriptionTerm`
+]);
+/** The properties of a caption's `<figure>`: its class, then the attributes written at the end of the caption (a class joins it). */
+const figureProperties = (author) => {
+	const { class: extraClass, className: extraClassName, ...rest } = author ?? {};
+	const extra = [extraClass, extraClassName].flat().flatMap((value) => typeof value === `string` ? value.split(` `) : []).filter((value) => value !== ``);
+	return {
+		className: [CAPTION_CLASS, ...extra],
+		...rest
+	};
+};
+const WHITESPACE$1 = /^\s*$/;
+const onlyImages = (children) => children.some((child) => child.type !== `text`) && children.every((child, index) => child.type === `image` || child.type === `text` && (WHITESPACE$1.test(child.value ?? ``) || /^\s*!$/.test(child.value ?? ``) && children[index + 1]?.type === `image`) || child.type === `link` && (child.children ?? []).length > 0 && (child.children ?? []).every((inner) => inner.type === `image`));
+const figure = (content, caption, author) => ({
+	type: `figure`,
+	data: {
+		hName: `figure`,
+		hProperties: figureProperties(author)
+	},
+	children: [...content, {
+		type: `figcaption`,
+		data: { hName: `figcaption` },
+		children: caption
+	}]
+});
+const captionContent = (lines) => {
+	const first = lines[0]?.[0];
+	if (first?.type === `text`) {
+		const value = stripCaptionMarker(first.value);
+		lines[0] = value ? [{
+			...first,
+			value
+		}, ...lines[0].slice(1)] : lines[0].slice(1);
+	}
+	return linesToParagraph(lines)?.children ?? [];
+};
+const takeProperties = (node) => {
+	const data = node.data;
+	if (!data?.hProperties) return void 0;
+	const { hProperties, ...rest } = data;
+	node.data = rest;
+	return hProperties;
+};
+/**
+* Wrap each captioned block of an mdast tree, with its caption, in a `figure` node (`hName: "figure"`, class `markdown-caption`) whose last child is a `figcaption` node. `source` is the document the tree was parsed from: caption lines are found, and placed, by their source lines.
+*/
+const processCaptions = (root, source) => {
+	if (!source.includes(`~:`)) return;
+	const sourceLines = source.split(/\r?\n/);
+	const parents = /* @__PURE__ */ new Map();
+	const paragraphs = [];
+	const tables = [];
+	const walk = (node) => {
+		if (node.type === `paragraph`) paragraphs.push(node);
+		else if (node.type === `table`) tables.push(node);
+		for (const child of node.children ?? []) {
+			parents.set(child, node);
+			walk(child);
+		}
+	};
+	walk(root);
+	const replace = (node, replacement) => {
+		const parent = parents.get(node);
+		const siblings = parent?.children;
+		if (!parent || !siblings) return;
+		const index = siblings.indexOf(node);
+		if (index === -1) return;
+		if (replacement) {
+			siblings.splice(index, 1, replacement);
+			parents.set(replacement, parent);
+			parents.set(node, replacement);
+		} else siblings.splice(index, 1);
+	};
+	const captioned = (node) => parents.get(node)?.type === `figure`;
+	const ancestorsOf = (node) => {
+		const ancestors = [];
+		for (let p = parents.get(node); p; p = parents.get(p)) ancestors.unshift(p);
+		return ancestors;
+	};
+	const containersOf = (ancestors) => {
+		const containers = [];
+		const nearest = (index, type) => ancestors.slice(0, index).reverse().find((a) => a.type === type);
+		let quotes = 0;
+		for (const [index, ancestor] of ancestors.entries()) {
+			const quote = (target) => {
+				containers.push({
+					target: target ?? ancestor,
+					line: {
+						kind: `quote`,
+						markers: ++quotes
+					}
+				});
+			};
+			switch (ancestor.type) {
+				case `blockquote`:
+				case `alert`:
+					quote(ancestor);
+					break;
+				case `tabsItem`:
+				case `tabsPanel`:
+					quote(nearest(index, `tabsList`));
+					break;
+				case `stepsItem`:
+					if (!(ancestor.children ?? []).some((c) => c.type === `stepsBody`)) quote(nearest(index, `stepsList`));
+					break;
+				case `stepsBody`:
+					quote(nearest(index, `stepsList`));
+					break;
+				case `listItem`:
+				case `defListDescription`:
+				case `descriptionDetails`: {
+					const column = ancestor.children?.[0]?.position?.start.column;
+					if (column === void 0) return void 0;
+					containers.push({
+						target: ancestors[index - 1] ?? ancestor,
+						line: {
+							kind: `item`,
+							column: column - 1
+						}
+					});
+					break;
+				}
+			}
+		}
+		return containers;
+	};
+	for (const table of tables) {
+		const rows = table.children ?? [];
+		const first = rows.findIndex((row, index) => {
+			const line = row.position?.start.line;
+			const text = row.children?.[0]?.children?.[0];
+			return index > 0 && line !== void 0 && isCaptionLine(sourceLines[line - 1] ?? ``) && text?.type === `text` && startsCaption(text.value ?? ``);
+		});
+		if (first === -1) continue;
+		const captionRows = rows.slice(first);
+		const lastCell = captionRows.at(-1)?.children?.[0];
+		const author = lastCell ? takeProperties(lastCell) : void 0;
+		const caption = captionContent(captionRows.map((row) => row.children?.[0]?.children ?? []));
+		table.children = rows.slice(0, first);
+		replace(table, figure([table], caption, author));
+	}
+	for (const para of paragraphs.reverse()) {
+		const first = para.position?.start.line;
+		if (first === void 0) continue;
+		const lines = paraToLines(para, sourceLines);
+		const parent = parents.get(para);
+		const start = (parent?.type === `alert` || parent?.type === `blockquote` && parent.data?.alertType !== void 0) && isAlertMarkerLine(sourceLines[first - 1] ?? ``) ? first + 1 : first;
+		const isCaptionAt = (index) => {
+			const text = lines[index]?.[0];
+			return isCaptionLine(sourceLines[start + index - 1] ?? ``) && text?.type === `text` && startsCaption(text.value);
+		};
+		if (isCaptionAt(0)) {
+			const siblings = parents.get(para)?.children ?? [];
+			const before = siblings[siblings.indexOf(para) - 1];
+			const above = sourceLines[start - 2];
+			if (!before || UNCAPTIONED.has(before.type) || above === void 0 || above.replace(/^[ \t>]*/, ``) === ``) continue;
+			const author = takeProperties(para);
+			replace(para, null);
+			replace(before, figure([before], captionContent(lines), author));
+			continue;
+		}
+		let containers;
+		const segments = [];
+		for (let index = 1; index < lines.length; index++) {
+			if (!isCaptionAt(index)) continue;
+			containers ??= containersOf(ancestorsOf(para));
+			if (!containers) break;
+			const kept = containersKept(sourceLines[start + index - 1] ?? ``, containers.map((c) => c.line));
+			const previous = segments.at(-1);
+			if (previous && kept >= previous.kept) continue;
+			const target = containers[kept]?.target ?? para;
+			if (captioned(target)) continue;
+			segments.push({
+				index,
+				kept,
+				target
+			});
+		}
+		if (segments.length === 0) continue;
+		const head = lines.slice(0, segments[0].index);
+		const lastLine = head.at(-1);
+		if (lastLine?.at(-1)?.type === `break`) head[head.length - 1] = lastLine.slice(0, -1);
+		para.children = linesToParagraph(head)?.children ?? [];
+		const author = takeProperties(para);
+		for (const [i, segment] of segments.entries()) {
+			const caption = captionContent(lines.slice(segment.index, segments[i + 1]?.index));
+			const properties = i === segments.length - 1 ? author : void 0;
+			const { target } = segment;
+			if (target === para && onlyImages(para.children ?? [])) replace(para, figure(para.children ?? [], caption, properties));
+			else replace(target, figure([target], caption, properties));
+		}
+	}
+};
+// src/hast.ts
+const WHITESPACE = /^[ \t\n\f\r]*$/;
+const isWhitespaceText = (node) => node.type === `text` && WHITESPACE.test(node.value ?? ``);
+/** A `<p>` with no children, or only whitespace text: squeeze-paragraphs removes it. */
+const isEmptyParagraph = (node) => node.tagName === `p` && (node.children ?? []).every(isWhitespaceText);
+/**
+* A `<p>` whose content is only images (each possibly inside a link or a lightbox button) and whitespace: unwrap-images replaces it with its children.
+*/
+const isImageParagraph = (node) => {
+	const scan = (parent, inLink) => {
+		let result = `empty`;
+		for (const child of parent.children ?? []) {
+			if (isWhitespaceText(child)) continue;
+			if (child.type !== `element`) return `other`;
+			if (child.tagName === `img`) {
+				result = `image`;
+				continue;
+			}
+			if (!inLink && (child.tagName === `a` || child.tagName === `button`)) {
+				const inner = scan(child, true);
+				if (inner === `other`) return `other`;
+				if (inner === `image`) result = `image`;
+				continue;
+			}
+			return `other`;
+		}
+		return result;
+	};
+	return node.tagName === `p` && scan(node, false) === `image`;
+};
+/** The rank of an `h1`–`h6` element, or `undefined`. */
+const headingRank = (node) => {
+	if (node.type !== `element`) return void 0;
+	const match = /^h([1-6])$/i.exec(node.tagName ?? ``);
+	return match ? Number(match[1]) : void 0;
+};
+/**
+* Wrap heading-delimited runs of `nodes` into `<section data-depth>` elements, nesting deeper headings inside shallower ones. Content before the first heading stays unwrapped.
+*/
+const sectionize = (nodes, section, floor = 0) => {
+	let minRank = Infinity;
+	for (const node of nodes) {
+		const rank = headingRank(node);
+		if (rank !== void 0 && rank > floor && rank < minRank) minRank = rank;
+	}
+	if (minRank === Infinity) return [...nodes];
+	const result = [];
+	let i = 0;
+	for (; i < nodes.length; i++) {
+		const node = nodes[i];
+		if (!node || headingRank(node) === minRank) break;
+		result.push(node);
+	}
+	while (i < nodes.length) {
+		const start = i;
+		for (i++; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (!node || headingRank(node) === minRank) break;
+		}
+		result.push(section(minRank, sectionize(nodes.slice(start, i), section, minRank)));
+	}
+	return result;
+};
+/**
+* The lightbox opt-in: an image directly after a text run that ends in a `!` at a boundary (start of the run or after whitespace), which is what `!![alt](src)` leaves behind.
+*/
+const LIGHTBOX_MARKER = /(?:^|\s)!$/;
+/**
+* A short, stable lightbox id from an image src (FNV-1a, base36): the same image always gets the same id, so repeated references share one dialog.
+*/
+const lightboxId = (src) => {
+	let hash = 2166136261;
+	for (let i = 0; i < src.length; i += 1) {
+		hash ^= src.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return `markdown-lightbox-${(hash >>> 0).toString(36)}`;
+};
+/** The button that replaces an opted-in image and opens its dialog. */
+const lightboxTrigger = (id, image) => ({
+	type: `element`,
+	tagName: `button`,
+	properties: {
+		type: `button`,
+		className: [`markdown-lightbox-trigger`],
+		command: `show-modal`,
+		commandfor: id
+	},
+	children: [image]
+});
+/** The modal dialog, appended at the document end, showing the image full size, and its caption under it when one is given. */
+const lightboxDialog = (id, image, caption) => ({
+	type: `element`,
+	tagName: `dialog`,
+	properties: {
+		id,
+		className: [`markdown-lightbox`],
+		closedby: `any`
+	},
+	children: [{
+		type: `element`,
+		tagName: `button`,
+		properties: {
+			type: `button`,
+			className: [`markdown-lightbox-close`],
+			command: `close`,
+			commandfor: id,
+			ariaLabel: `Close image`
+		},
+		children: [image]
+	}, ...caption ? [{
+		type: `element`,
+		tagName: `p`,
+		properties: { className: [`markdown-lightbox-caption`] },
+		children: caption
+	}] : []]
+});
+/** Whether a node is a caption's figure (`<figure class="markdown-caption">`, as the caption plugins make): an image that is its content shows the figure's caption in its lightbox dialog, with the `caption` option. */
+const isCaptionFigure = (node) => {
+	const className = node?.properties?.className;
+	return node?.tagName === `figure` && Array.isArray(className) && className.includes("markdown-caption");
+};
+// src/abbr.ts
+const DEFINITION = /^\*\[([^[\]]+)\]:\s*(.+)$/;
+const REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+/**
+* The `[term, title]` pairs a paragraph's text defines, when every line of it is a `*[term]: title` definition; otherwise `undefined` (the paragraph is ordinary text).
+*/
+const parseAbbreviations = (text) => {
+	const definitions = [];
+	for (const line of text.split(`\n`)) {
+		const match = DEFINITION.exec(line);
+		if (!match) return void 0;
+		definitions.push([match[1] ?? ``, (match[2] ?? ``).trim()]);
+	}
+	return definitions;
+};
+/**
+* Build the scan for a document's abbreviations. Terms match on word boundaries, longest first; the scan returns the pieces of a text value, or `undefined` when it holds no term.
+*/
+const createAbbreviationScan = (abbreviations) => {
+	const terms = [...abbreviations.keys()].sort((a, b) => b.length - a.length).map((term) => term.replace(REGEX_SPECIAL, `\\$&`));
+	const pattern = new RegExp(`\\b(${terms.join(`|`)})\\b`, `g`);
+	return (value) => {
+		const parts = [];
+		let last = 0;
+		for (const match of value.matchAll(pattern)) {
+			const term = match[1] ?? ``;
+			if (match.index > last) parts.push({ text: value.slice(last, match.index) });
+			parts.push({
+				term,
+				title: abbreviations.get(term) ?? ``
+			});
+			last = match.index + term.length;
+		}
+		if (parts.length === 0) return void 0;
+		if (last < value.length) parts.push({ text: value.slice(last) });
+		return parts;
+	};
+};
+// src/steps.ts
+const STEP_HEADER_RE = /^(@{1,6})(\d+)\. ?(.*)/s;
+const parseHeaderPrefix = (text) => {
+	const m = STEP_HEADER_RE.exec(text);
+	if (!m) return null;
+	const [, hashes = "", digits = "", rest = ""] = m;
+	return {
+		depth: hashes.length,
+		number: parseInt(digits, 10),
+		rest
+	};
+};
+const extractHeaderPara$1 = (para, counters, requireDepthOne = true, prevDepth = 0) => {
+	const lines = paraToLines(para);
+	const steps = [];
+	let currentDepth = prevDepth;
+	const stop = (index) => steps.length > 0 ? {
+		steps,
+		rest: lines.slice(index),
+		restLine: (para.position?.start.line ?? 1) + index
+	} : null;
+	for (const [index, lineSegs] of lines.entries()) {
+		const first = lineSegs[0];
+		if (first?.type !== "text") return stop(index);
+		const header = parseHeaderPrefix(first.value);
+		if (!header) return stop(index);
+		const { depth } = header;
+		if (steps.length === 0 && requireDepthOne && depth !== 1) return null;
+		if (depth > currentDepth + 1) return stop(index);
+		for (const k of counters.keys()) if (k > depth) counters.delete(k);
+		const number = (counters.get(depth) ?? 0) + 1;
+		counters.set(depth, number);
+		currentDepth = depth;
+		const titleNodes = header.rest ? [{
+			type: "text",
+			value: header.rest
+		}, ...lineSegs.slice(1)] : lineSegs.slice(1);
+		steps.push({
+			depth,
+			number,
+			titleNodes,
+			body: [],
+			...index === lines.length - 1 ? { hProperties: paragraphProperties(para) } : {}
+		});
+	}
+	return stop(lines.length);
+};
+const splitAtGroupStarts$1 = (lines, firstLine) => {
+	const paragraphs = [];
+	let start = 0;
+	const flush = (end) => {
+		const para = linesToParagraph(lines.slice(start, end));
+		if (!para) return;
+		para.position = {
+			start: {
+				line: firstLine + start,
+				column: 1
+			},
+			end: {
+				line: firstLine + end - 1,
+				column: 1
+			}
+		};
+		paragraphs.push(para);
+	};
+	lines.forEach((line, index) => {
+		const first = line[0];
+		if (first?.type === "text" && parseHeaderPrefix(first.value)?.depth === 1 && index > start) {
+			flush(index);
+			start = index;
+		}
+	});
+	flush(lines.length);
+	return paragraphs;
+};
+const takeLazyLines = (node, sourceLines, base, isHeader) => {
+	let parent = node;
+	let last = parent.children?.at(-1);
+	while (last?.type !== "paragraph") {
+		if (!last?.children?.length) return null;
+		parent = last;
+		last = parent.children?.at(-1);
+	}
+	const para = last;
+	const start = para.position?.start.line;
+	if (start === void 0 || !parent.children) return null;
+	const lines = paraToLines(para, sourceLines).map((segs, index) => ({
+		segs,
+		markers: markerCount(sourceLines[start - 1 + index] ?? "")
+	}));
+	const at = lines.findIndex(({ segs, markers }, index) => index > 0 && markers < base && isHeader(segs));
+	if (at === -1) return null;
+	const kept = linesToParagraph(lines.slice(0, at).map(({ segs }) => segs));
+	parent.children.splice(-1, 1, ...kept ? [kept] : []);
+	return lines.slice(at);
+};
+const splitBlockquote$1 = (bq, counters, currentDepth, sourceLines) => {
+	const segments = [];
+	let currentSegment = {
+		header: null,
+		body: []
+	};
+	const base = sourceLines ? blockquoteMarkers(bq, sourceLines) : void 0;
+	const stepHeader = (lineSegs) => {
+		const first = lineSegs[0];
+		if (first?.type !== "text") return null;
+		const header = parseHeaderPrefix(first.value);
+		return header && header.depth <= currentDepth + 1 ? header : null;
+	};
+	const startStep = (header, lineSegs, hProperties) => {
+		segments.push(currentSegment);
+		for (const k of counters.keys()) if (k > header.depth) counters.delete(k);
+		const number = (counters.get(header.depth) ?? 0) + 1;
+		counters.set(header.depth, number);
+		currentDepth = header.depth;
+		const titleNodes = header.rest ? [{
+			type: "text",
+			value: header.rest
+		}, ...lineSegs.slice(1)] : lineSegs.slice(1);
+		currentSegment = {
+			header: {
+				depth: header.depth,
+				number,
+				titleNodes,
+				hProperties
+			},
+			body: []
+		};
+	};
+	for (const child of bq.children) {
+		if (child.type !== "paragraph") {
+			currentSegment.body.push(child);
+			if (!sourceLines || base === void 0) continue;
+			const lazy = takeLazyLines(child, sourceLines, base, (segs) => stepHeader(segs) !== null);
+			if (!lazy) continue;
+			let pending = [];
+			const flush = () => {
+				const relative = pending.map((line) => ({
+					...line,
+					markers: line.markers - base
+				}));
+				currentSegment.body.push(...rebuildLazyLines(relative, 0));
+				pending = [];
+			};
+			for (const line of lazy) {
+				const header = line.markers < base ? stepHeader(line.segs) : null;
+				if (header) {
+					flush();
+					startStep(header, line.segs);
+				} else pending.push(line);
+			}
+			flush();
+			continue;
+		}
+		let bodyLines = [];
+		const lines = paraToLines(child, sourceLines);
+		const first = child.position?.start.line;
+		const outsideBody = (index) => !sourceLines || base === void 0 || first === void 0 || markerCount(sourceLines[first - 1 + index] ?? "") < base;
+		for (const [index, lineSegs] of lines.entries()) {
+			const header = outsideBody(index) ? stepHeader(lineSegs) : null;
+			if (header) {
+				const bodyPara = linesToParagraph(bodyLines);
+				if (bodyPara) currentSegment.body.push(bodyPara);
+				bodyLines = [];
+				startStep(header, lineSegs, index === lines.length - 1 ? paragraphProperties(child) : void 0);
+				continue;
+			}
+			bodyLines.push(lineSegs);
+		}
+		const bodyPara = linesToParagraph(bodyLines);
+		if (bodyPara && child.data) bodyPara.data = child.data;
+		if (bodyPara) currentSegment.body.push(bodyPara);
+	}
+	segments.push(currentSegment);
+	return segments;
+};
+const buildTree$1 = (steps, targetDepth, start, end) => {
+	const items = [];
+	let i = start;
+	while (i < end) {
+		const s = steps[i];
+		if (s?.depth !== targetDepth) {
+			i++;
+			continue;
+		}
+		let childEnd = i + 1;
+		while (childEnd < end && (steps[childEnd]?.depth ?? 0) > targetDepth) childEnd++;
+		const bodyChildren = [{
+			type: "stepsTitle",
+			children: s.titleNodes
+		}, ...s.body];
+		if (steps.slice(i + 1, childEnd).some((ss) => ss.depth === targetDepth + 1)) {
+			const nested = buildTree$1(steps, targetDepth + 1, i + 1, childEnd);
+			bodyChildren.push(nested);
+		}
+		items.push({
+			type: "stepsItem",
+			depth: targetDepth,
+			number: s.number,
+			children: bodyChildren,
+			data: {
+				attrsRole: "containerItem",
+				attrsTitle: s.titleNodes,
+				...s.hProperties ? { hProperties: { ...s.hProperties } } : {}
+			}
+		});
+		i = childEnd;
+	}
+	return {
+		type: "stepsList",
+		depth: targetDepth,
+		children: items,
+		data: { attrsRole: "container" }
+	};
+};
+const processStepsInChildren = (children, containerClass, sourceLines, quotes = 0, parentType = "root") => {
+	const newChildren = [];
+	let i = 0;
+	while (i < children.length) {
+		const node = children[i];
+		if (!node) break;
+		if (node.type === "paragraph" && sourceLines && !INDENTED_BLOCKS.has(parentType)) {
+			const split = splitAtOpeningLine(node, sourceLines, quotes, (text) => parseHeaderPrefix(text)?.depth === 1);
+			if (split) {
+				children.splice(i, 1, ...split);
+				continue;
+			}
+		}
+		if (node.type === "paragraph") {
+			const counters = /* @__PURE__ */ new Map();
+			const headerPara = extractHeaderPara$1(node, counters);
+			if (headerPara) {
+				const rawSteps = [...headerPara.steps];
+				let rest = headerPara.rest;
+				let restLine = headerPara.restLine;
+				let j = i + 1;
+				const lastStep = () => rawSteps[rawSteps.length - 1];
+				let currentStepIdx = rawSteps.length - 1;
+				let currentDepth = lastStep().depth;
+				while (rest.length === 0 && j < children.length) {
+					const sibling = children[j];
+					if (!sibling) break;
+					if (sibling.type === "blockquote") {
+						const line = sibling.position?.start.line;
+						if (sourceLines && line !== void 0 && isAlertMarkerLine(sourceLines[line - 1] ?? "")) break;
+						const segments = splitBlockquote$1(sibling, counters, currentDepth, sourceLines);
+						const firstSeg = segments[0];
+						if (firstSeg?.header === null) rawSteps[currentStepIdx]?.body.push(...firstSeg.body);
+						for (let s = 1; s < segments.length; s++) {
+							const seg = segments[s];
+							if (seg?.header) {
+								rawSteps.push({
+									...seg.header,
+									body: seg.body
+								});
+								currentStepIdx = rawSteps.length - 1;
+								currentDepth = seg.header.depth;
+							}
+						}
+						j++;
+					} else if (sibling.type === "paragraph") {
+						const prevDepth = lastStep().depth;
+						const contHeaders = extractHeaderPara$1(sibling, counters, false, prevDepth);
+						if (contHeaders) {
+							rawSteps.push(...contHeaders.steps);
+							rest = contHeaders.rest;
+							restLine = contHeaders.restLine;
+							currentStepIdx = rawSteps.length - 1;
+							currentDepth = lastStep().depth;
+							j++;
+							continue;
+						}
+						break;
+					} else break;
+				}
+				const list = buildTree$1(rawSteps, 1, 0, rawSteps.length);
+				list.containerClass = containerClass;
+				if (parentType === "stepsItem") list.inBody = true;
+				newChildren.push(list);
+				children.splice(j, 0, ...splitAtGroupStarts$1(rest, restLine));
+				i = j;
+				continue;
+			}
+		}
+		newChildren.push(node);
+		i++;
+	}
+	children.splice(0, children.length, ...newChildren);
+};
+/**
+* Turn every step sequence in `root` into `stepsList` nodes, at the top level and inside any container (blockquotes, list items, tab panels…), walking into the lists it builds so nested sequences are found too. With the document's `source`, a step header that CommonMark lazily continued into a nested paragraph is recognized too, as markdown-it reads it.
+*/
+const processSteps = (root, containerClass, source) => {
+	const sourceLines = source?.split(/\r?\n/);
+	const walk = (node, quotes) => {
+		if (!Array.isArray(node.children) || node.children.length === 0) return;
+		const inner = quotes + (MARKED_BLOCKS.has(node.type ?? "") ? 1 : 0);
+		processStepsInChildren(node.children, containerClass, sourceLines, inner, node.type);
+		for (const child of node.children) walk(child, inner);
+	};
+	processStepsInChildren(root.children, containerClass, sourceLines);
+	for (const child of root.children) walk(child, 0);
+	if (sourceLines) endGroupsAtMarkers(root, sourceLines, `stepsList`);
+};
+// src/tabs.ts
+const TAB_HEADER_RE = /^(%{1,6})(\+)? (.*)/;
+const parseTabHeader = (line) => {
+	const m = TAB_HEADER_RE.exec(line);
+	if (!m) return null;
+	const [, percents = "", plus, label = ""] = m;
+	return {
+		depth: percents.length,
+		open: plus === "+",
+		label
+	};
+};
+const djb2 = (str) => {
+	let h = 5381;
+	for (let i = 0; i < str.length; i++) h = (h << 5) + h + str.charCodeAt(i) >>> 0;
+	return h;
+};
+/** Strip a trailing attrs block like `{.class #id}` from plain label text, so attrs-consumed markers don't leak into `aria-label`. */
+const stripAttrs = (text) => text.replace(/\s*\{[^}]*\}\s*$/, "").trimEnd();
+const slugify = (text) => text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "");
+const groupId = (labels) => {
+	const key = [...labels].map(slugify).sort().join("-");
+	return djb2(key).toString(16);
+};
+/**
+* A group's block id, unique on the page even when label sets match: its group id with the group's index among the document's tab groups, counted in the order they open (each nested group after the group around it), so every engine counts the same groups the same way.
+*/
+const tabsBlockId = (index, groupId) => "tabs-" + djb2(`${index}:${groupId}`).toString(16);
+/** The plain text of a tab label (text and inline code; other markup contributes its text, images nothing), for its group id and `aria-label`. */
+const tabLabelText = (nodes) => nodes.map((n) => {
+	if (n.type === "text" || n.type === "inlineCode") return "value" in n ? n.value : "";
+	if ("children" in n) return tabLabelText(n.children);
+	return "";
+}).join("");
+const extractHeaderPara = (para, requireDepthOne = true, prevDepth = 0) => {
+	const lines = paraToLines(para);
+	const tabs = [];
+	let currentDepth = prevDepth;
+	for (const [index, lineSegs] of lines.entries()) {
+		const first = lineSegs[0];
+		if (first?.type !== "text") return null;
+		const header = parseTabHeader(first.value);
+		if (!header) return null;
+		const { depth, open } = header;
+		if (tabs.length === 0 && requireDepthOne && depth !== 1) return null;
+		if (depth > currentDepth + 1) return tabs.length > 0 ? {
+			tabs,
+			rest: lines.slice(index),
+			restLine: (para.position?.start.line ?? 1) + index
+		} : null;
+		currentDepth = depth;
+		const labelText = header.label;
+		const labelNodes = labelText ? [{
+			type: "text",
+			value: labelText
+		}, ...lineSegs.slice(1)] : lineSegs.slice(1);
+		tabs.push({
+			depth,
+			open,
+			labelNodes,
+			labelText: tabLabelText(labelNodes),
+			body: [],
+			...index === lines.length - 1 ? { hProperties: paragraphProperties(para) } : {}
+		});
+	}
+	return tabs.length > 0 ? {
+		tabs,
+		rest: [],
+		restLine: 0
+	} : null;
+};
+const splitAtGroupStarts = (lines, firstLine) => {
+	const paragraphs = [];
+	let start = 0;
+	const flush = (end) => {
+		const para = linesToParagraph(lines.slice(start, end));
+		if (!para) return;
+		para.position = {
+			start: {
+				line: firstLine + start,
+				column: 1
+			},
+			end: {
+				line: firstLine + end - 1,
+				column: 1
+			}
+		};
+		paragraphs.push(para);
+	};
+	lines.forEach((line, index) => {
+		const first = line[0];
+		if (first?.type === "text" && parseTabHeader(first.value)?.depth === 1 && index > start) {
+			flush(index);
+			start = index;
+		}
+	});
+	flush(lines.length);
+	return paragraphs;
+};
+const isExplicitBQ = (bq) => bq.children.some((child) => {
+	if (child.type !== "paragraph") return false;
+	const first = child.children[0];
+	return first?.type === "text" && parseTabHeader(first.value.split("\n")[0] ?? "") !== null;
+});
+const extractTrailingTabHeader = (node, sourceLines) => {
+	const path = [];
+	let current = node;
+	while ("children" in current && current.children.length > 0) {
+		const last = current.children[current.children.length - 1];
+		if (last.type === "paragraph") {
+			path.push(current);
+			const lines = paraToLines(last, sourceLines);
+			const at = lines.findIndex((line) => line[0]?.type === "text" && parseTabHeader(line[0].value));
+			if (at === -1) return null;
+			const headerLine = lines[at] ?? [];
+			const first = headerLine[0];
+			const header = first?.type === "text" ? parseTabHeader(first.value) : null;
+			if (!header) return null;
+			const labelText = header.label;
+			const labelNodes = labelText ? [{
+				type: "text",
+				value: labelText
+			}, ...headerLine.slice(1)] : headerLine.slice(1);
+			return {
+				header: {
+					depth: header.depth,
+					open: header.open,
+					labelNodes,
+					labelText: tabLabelText(labelNodes),
+					body: [],
+					...at === lines.length - 1 ? { hProperties: paragraphProperties(last) } : {}
+				},
+				truncatedPara: linesToParagraph(lines.slice(0, at)),
+				rest: lines.slice(at + 1),
+				path,
+				start: last.position?.start.line,
+				at,
+				line: headerLine
+			};
+		}
+		if (!("children" in last)) break;
+		path.push(current);
+		current = last;
+	}
+	return null;
+};
+const splitBlockquote = (bq, explicit, sourceLines) => {
+	const segments = [];
+	let currentSegment = {
+		header: null,
+		body: [],
+		explicit,
+		lines: []
+	};
+	const base = sourceLines && !explicit ? blockquoteMarkers(bq, sourceLines) : void 0;
+	const splitLines = (lines, markersOf, para) => {
+		let bodyLines = [];
+		for (const [index, lineSegs] of lines.entries()) {
+			const first = lineSegs[0];
+			const outsidePanel = !markersOf || base === void 0 || markersOf(index) < base;
+			if (first?.type === "text" && outsidePanel) {
+				const header = parseTabHeader(first.value);
+				if (header) {
+					if (bodyLines.length > 0) {
+						const bodyPara = linesToParagraph(bodyLines);
+						if (bodyPara) currentSegment.body.push(bodyPara);
+						bodyLines = [];
+					}
+					segments.push(currentSegment);
+					const labelText = header.label;
+					const labelNodes = labelText ? [{
+						type: "text",
+						value: labelText
+					}, ...lineSegs.slice(1)] : lineSegs.slice(1);
+					currentSegment = {
+						header: {
+							depth: header.depth,
+							open: header.open,
+							labelNodes,
+							labelText: tabLabelText(labelNodes),
+							body: [],
+							...para && index === lines.length - 1 ? { hProperties: paragraphProperties(para) } : {}
+						},
+						body: [],
+						explicit,
+						lines: [],
+						line: lineSegs,
+						...markersOf ? { markers: markersOf(index) } : {}
+					};
+					continue;
+				}
+			}
+			bodyLines.push(lineSegs);
+			if (markersOf) currentSegment.lines.push({
+				segs: lineSegs,
+				markers: markersOf(index)
+			});
+		}
+		if (bodyLines.length > 0) {
+			const bodyPara = linesToParagraph(bodyLines);
+			if (bodyPara && para?.data) bodyPara.data = para.data;
+			if (bodyPara) currentSegment.body.push(bodyPara);
+		}
+	};
+	for (const child of bq.children) {
+		if (child.type !== "paragraph") {
+			const extracted = extractTrailingTabHeader(child, sourceLines);
+			if (extracted) {
+				const cloned = JSON.parse(JSON.stringify(child));
+				let target = cloned;
+				for (let pi = 1; pi < extracted.path.length; pi++) target = target.children[target.children.length - 1];
+				const deepestParent = target;
+				if (extracted.truncatedPara) deepestParent.children[deepestParent.children.length - 1] = extracted.truncatedPara;
+				else deepestParent.children.splice(deepestParent.children.length - 1, 1);
+				currentSegment.body.push(cloned);
+				segments.push(currentSegment);
+				const { start, at } = extracted;
+				const markersOf = sourceLines && start !== void 0 ? (index) => markerCount(sourceLines[start - 1 + index] ?? "") : void 0;
+				currentSegment = {
+					header: extracted.header,
+					body: [],
+					explicit,
+					lines: [],
+					line: extracted.line,
+					...markersOf ? { markers: markersOf(at) } : {}
+				};
+				splitLines(extracted.rest, markersOf ? (index) => markersOf(at + 1 + index) : void 0);
+			} else currentSegment.body.push(child);
+			continue;
+		}
+		const start = child.position?.start.line;
+		splitLines(paraToLines(child, sourceLines), sourceLines && start !== void 0 ? (index) => markerCount(sourceLines[start - 1 + index] ?? "") : void 0, child);
+	}
+	segments.push(currentSegment);
+	return segments;
+};
+const afterSkip = (segments, level, quoted) => {
+	const lines = [];
+	const blocks = [];
+	for (const seg of segments) {
+		if (level === void 0 || seg.markers === void 0) {
+			if (seg.line) lines.push({
+				segs: seg.line,
+				markers: 0
+			});
+			blocks.push(...seg.body);
+			continue;
+		}
+		if (seg.line) lines.push({
+			segs: seg.line,
+			markers: seg.markers - level
+		});
+		lines.push(...seg.lines.map((line) => ({
+			...line,
+			markers: line.markers - level
+		})));
+		blocks.push(...seg.body.filter((block) => block.type !== "paragraph"));
+	}
+	const content = rebuildLazyLines(lines, 0);
+	if (blocks.length > 0 && !quoted) content.push(...blocks);
+	else if (blocks.length > 0) {
+		const last = content.at(-1);
+		if (last?.type === "blockquote") last.children.push(...blocks);
+		else content.push({
+			type: "blockquote",
+			children: blocks
+		});
+	}
+	return content;
+};
+const buildTree = (rawTabs, targetDepth, start, end, containerClass) => {
+	const depthLabels = rawTabs.slice(start, end).filter((t) => t.depth === targetDepth).map((t) => stripAttrs(t.labelText));
+	const gId = groupId(depthLabels);
+	const explicitOpenIdx = rawTabs.slice(start, end).findIndex((t) => t.depth === targetDepth && t.open);
+	const explicitOpenAbsIdx = explicitOpenIdx >= 0 ? start + explicitOpenIdx : -1;
+	const items = [];
+	let tabCounter = 0;
+	let i = start;
+	while (i < end) {
+		const raw = rawTabs[i];
+		if (!raw) break;
+		if (raw.depth !== targetDepth) {
+			i++;
+			continue;
+		}
+		let childEnd = i + 1;
+		while (childEnd < end && (rawTabs[childEnd]?.depth ?? 0) > targetDepth) childEnd++;
+		const isOpen = explicitOpenAbsIdx >= 0 ? i === explicitOpenAbsIdx : tabCounter === 0;
+		const bodyChildren = [{
+			type: "tabsLabel",
+			children: raw.labelNodes
+		}, ...raw.body];
+		if (rawTabs.slice(i + 1, childEnd).some((t) => t.depth === targetDepth + 1)) {
+			const nested = buildTree(rawTabs, targetDepth + 1, i + 1, childEnd, containerClass);
+			nested.containerClass = containerClass;
+			bodyChildren.push(nested);
+		}
+		bodyChildren.push(...raw.after ?? []);
+		items.push({
+			type: "tabsItem",
+			depth: targetDepth,
+			labelText: raw.labelText,
+			open: isOpen,
+			children: bodyChildren,
+			data: {
+				attrsRole: "containerItem",
+				attrsTitle: raw.labelNodes,
+				attrsItemTitle: true,
+				hProperties: { ...raw.hProperties }
+			}
+		});
+		tabCounter++;
+		i = childEnd;
+	}
+	return {
+		type: "tabsList",
+		depth: targetDepth,
+		groupId: gId,
+		children: items,
+		data: {
+			attrsRole: "container",
+			hProperties: {}
+		}
+	};
+};
+const processTabsInChildren = (children, containerClass, checkBlankLines = true, sourceLines, quotes = 0, parentType = "root") => {
+	const newChildren = [];
+	let i = 0;
+	while (i < children.length) {
+		const node = children[i];
+		if (!node) break;
+		if (node.type === "paragraph" && sourceLines && !INDENTED_BLOCKS.has(parentType)) {
+			const split = splitAtOpeningLine(node, sourceLines, quotes, (text) => parseTabHeader(text)?.depth === 1);
+			if (split) {
+				children.splice(i, 1, ...split);
+				continue;
+			}
+		}
+		if (node.type === "paragraph") {
+			const headerPara = extractHeaderPara(node);
+			if (headerPara) {
+				const rawTabs = [...headerPara.tabs];
+				const lastTab = () => rawTabs[rawTabs.length - 1];
+				let rest = headerPara.rest;
+				let restLine = headerPara.restLine;
+				let j = i + 1;
+				let currentTabIdx = rawTabs.length - 1;
+				let prevEndLine = node.position?.end.line ?? 0;
+				while (rest.length === 0 && j < children.length) {
+					const sibling = children[j];
+					if (!sibling) break;
+					const siblingStartLine = sibling.position?.start.line ?? prevEndLine + 1;
+					if (checkBlankLines && siblingStartLine > prevEndLine + 1) break;
+					if (sibling.type === "blockquote") {
+						const bq = sibling;
+						const explicit = isExplicitBQ(bq);
+						const segments = splitBlockquote(bq, explicit, sourceLines);
+						const base = explicit && sourceLines ? blockquoteMarkers(bq, sourceLines) : void 0;
+						const firstSeg = segments[0];
+						if (firstSeg?.header === null) rawTabs[currentTabIdx]?.body.push(...firstSeg.body);
+						const depthOffset = explicit ? lastTab().depth : 0;
+						const owner = lastTab();
+						let ending = null;
+						for (const [index, seg] of segments.slice(1).entries()) {
+							if (!seg.header) continue;
+							const markers = seg.markers;
+							if (explicit && markers !== void 0 && base !== void 0 && markers < base) {
+								if (seg.header.depth > lastTab().depth + 1) continue;
+								const relative = seg.lines.map((line) => ({
+									...line,
+									markers: line.markers - (markers + 1)
+								}));
+								seg.header.body.push(...rebuildLazyLines(relative, 0), ...seg.body.slice(seg.lines.length > 0 ? 1 : 0));
+								rawTabs.push(seg.header);
+								currentTabIdx = rawTabs.length - 1;
+								continue;
+							}
+							const adjustedDepth = depthOffset + seg.header.depth;
+							if (adjustedDepth > lastTab().depth + 1) {
+								if (explicit) {
+									owner.after = [...owner.after ?? [], ...afterSkip([seg], base, false)];
+									continue;
+								}
+								const quoteMarkers = sourceLines ? blockquoteMarkers(bq, sourceLines) : void 0;
+								ending = afterSkip(segments.slice(index + 1), quoteMarkers === void 0 ? void 0 : quoteMarkers - 1, true);
+								break;
+							}
+							seg.header.depth = adjustedDepth;
+							if (explicit) {
+								const deferredInnerSegs = [];
+								const escapedSegs = [];
+								for (const b of seg.body) {
+									if (b.type !== "blockquote") {
+										const escaped = escapedSegs.at(-1);
+										if (escaped) escaped.body.push(b);
+										else seg.header.body.push(b);
+										continue;
+									}
+									const innerBq = b;
+									if (!isExplicitBQ(innerBq)) {
+										const innerSegs = splitBlockquote(innerBq, false, sourceLines);
+										const innerFirst = innerSegs[0];
+										if (innerFirst?.header === null) seg.header.body.push(...innerFirst.body);
+										for (const innerSeg of innerSegs.slice(1)) {
+											if (!innerSeg.header) continue;
+											const markers = innerSeg.markers;
+											if (markers !== void 0 && base !== void 0) {
+												if (markers < base) {
+													const relative = innerSeg.lines.map((line) => ({
+														...line,
+														markers: line.markers - (markers + 1)
+													}));
+													innerSeg.header.body.push(...rebuildLazyLines(relative, 0));
+													escapedSegs.push(innerSeg.header);
+													deferredInnerSegs.push(innerSeg);
+													continue;
+												}
+											} else if (innerSeg.body.length === 0) {
+												innerSeg.header.depth = depthOffset;
+												escapedSegs.push(innerSeg.header);
+												deferredInnerSegs.push(innerSeg);
+												continue;
+											}
+											const tentativeDepth = depthOffset + innerSeg.header.depth;
+											if (tentativeDepth > lastTab().depth + 1) continue;
+											innerSeg.header.depth = tentativeDepth;
+											innerSeg.header.body.push(...innerSeg.body);
+											deferredInnerSegs.push(innerSeg);
+										}
+									} else seg.header.body.push(...innerBq.children);
+								}
+								rawTabs.push(seg.header);
+								currentTabIdx = rawTabs.length - 1;
+								for (const innerSeg of deferredInnerSegs) {
+									if (!innerSeg.header) continue;
+									rawTabs.push(innerSeg.header);
+									currentTabIdx = rawTabs.length - 1;
+								}
+							} else {
+								seg.header.body.push(...seg.body);
+								rawTabs.push(seg.header);
+								currentTabIdx = rawTabs.length - 1;
+							}
+						}
+						prevEndLine = sibling.position?.end.line ?? prevEndLine;
+						j++;
+						if (ending) {
+							children.splice(j, 0, ...ending);
+							break;
+						}
+					} else if (sibling.type === "paragraph") {
+						const prevDepth = lastTab().depth;
+						const contHeaders = extractHeaderPara(sibling, false, prevDepth);
+						if (contHeaders) {
+							rawTabs.push(...contHeaders.tabs);
+							rest = contHeaders.rest;
+							restLine = contHeaders.restLine;
+							currentTabIdx = rawTabs.length - 1;
+							prevEndLine = sibling.position?.end.line ?? prevEndLine;
+							j++;
+							continue;
+						}
+						break;
+					} else break;
+				}
+				const list = buildTree(rawTabs, 1, 0, rawTabs.length, containerClass);
+				list.containerClass = containerClass;
+				newChildren.push(list);
+				children.splice(j, 0, ...splitAtGroupStarts(rest, restLine));
+				i = j;
+				continue;
+			}
+		}
+		newChildren.push(node);
+		i++;
+	}
+	children.splice(0, children.length, ...newChildren);
+};
+/**
+* Recognize every tab group in the tree: at the root, then inside every container (step bodies, list items, other tabs' panels). Blank-line checks only apply at the root: blank lines inside a blockquote leave position gaps that would wrongly end a group once its content has been lifted out of the blockquote. With the document's `source`, a tab header that CommonMark lazily continued into a nested panel is placed by its `>` markers, as markdown-it reads it.
+*/
+const processTabs = (root, containerClass, source) => {
+	const sourceLines = source?.split(/\r?\n/);
+	const walk = (node, quotes) => {
+		if (!Array.isArray(node.children) || node.children.length === 0) return;
+		const inner = quotes + (MARKED_BLOCKS.has(node.type ?? "") ? 1 : 0);
+		processTabsInChildren(node.children, containerClass, false, sourceLines, inner, node.type);
+		for (const child of node.children) walk(child, inner);
+	};
+	processTabsInChildren(root.children, containerClass, true, sourceLines);
+	for (const child of root.children) walk(child, 0);
+	if (sourceLines) endGroupsAtMarkers(root, sourceLines, `tabsList`);
+};
+// src/editable.ts
+const editableTree = (root, build, setChildren, setData) => {
+	const originals = /* @__PURE__ */ new Map();
+	const copy = (node) => {
+		const children = node.children;
+		if (!children) {
+			const leaf = { ...node };
+			originals.set(leaf, {
+				node,
+				children: []
+			});
+			return leaf;
+		}
+		const branch = {
+			...node,
+			children: children.map(copy)
+		};
+		originals.set(branch, {
+			node,
+			children
+		});
+		return branch;
+	};
+	const writeBack = (node) => {
+		const original = originals.get(node);
+		if (!original) return build(node, writeBack);
+		if (setData && node.data !== original.node.data) setData(original.node, node.data);
+		if (!node.children) return original.node;
+		const children = node.children.map(writeBack);
+		if (children.length !== original.children.length || children.some((child, index) => child !== original.children[index])) setChildren(original.node, children);
+		return original.node;
+	};
+	return {
+		tree: copy(root),
+		writeBack
+	};
+};
+// src/inline-svg.ts
+const hash$1 = (str) => {
+	let h = 2166136261;
+	for (let i = 0; i < str.length; i++) h = Math.imul(h ^ str.charCodeAt(i), 16777619) >>> 0;
+	return h.toString(36);
+};
+/**
+* The id of a deduplicated SVG's sprite: a hash of its path relative to the document, with `/` separators, so the same document renders the same ids on any machine or OS (an absolute path would leak the build machine into the HTML).
+*/
+const svgSpriteId = (relativePath) => `svg-sprite-${hash$1(relativePath)}`;
+const extractSvgParts = (content) => {
+	const openTag = /<svg([^>]*?)>/i.exec(content)?.[1] ?? ``;
+	return {
+		viewBox: /viewBox="([^"]*)"/i.exec(openTag)?.[1] ?? ``,
+		width: /\bwidth="([^"]*)"/i.exec(openTag)?.[1] ?? ``,
+		height: /\bheight="([^"]*)"/i.exec(openTag)?.[1] ?? ``,
+		inner: /<svg[^>]*>([\s\S]*?)<\/svg\s*>/i.exec(content)?.[1]?.trim() ?? ``
+	};
+};
+const escAttr = (s) => s.replace(/&/g, `&amp;`).replace(/"/g, `&quot;`);
+const buildFullInline = (content, alt) => {
+	if (!alt) return content;
+	return content.replace(/<svg([^>]*)>/i, `<svg$1 aria-label="${escAttr(alt)}">`);
+};
+const buildSpriteHtml = (id, viewBox, inner) => `<svg aria-hidden="true" style="display:none" xmlns="http://www.w3.org/2000/svg"><defs><symbol id="${id}" viewBox="${escAttr(viewBox)}">${inner}</symbol></defs></svg>`;
+const buildUseHtml = (id, viewBox, width, height, alt) => {
+	return `<svg ${[
+		viewBox && `viewBox="${escAttr(viewBox)}"`,
+		width && `width="${escAttr(width)}"`,
+		height && `height="${escAttr(height)}"`,
+		alt && `aria-label="${escAttr(alt)}"`
+	].filter(Boolean).join(` `)}><use href="#${id}"></use></svg>`;
+};
+/**
+* The markup for every occurrence of one SVG file, given each occurrence's alt text in document order: the SVG itself, or, with deduplication and more than one occurrence, a hidden sprite on the first and a `<use>` of it on each. `null` when the limits leave the images as they are. `relativePath` is the file's path relative to the document, with `/` separators, for the sprite id.
+*/
+const inlineSvgMarkup = (content, alts, relativePath, limits) => {
+	if (content.length > limits.maxImageSize) return null;
+	if (alts.length > limits.maxOccurrences) return null;
+	if (alts.length * content.length > limits.maxTotalSize) return null;
+	if (!limits.deduplication || alts.length < 2) return alts.map((alt) => buildFullInline(content, alt));
+	const { viewBox, width, height, inner } = extractSvgParts(content);
+	const id = svgSpriteId(relativePath);
+	const sprite = buildSpriteHtml(id, viewBox, inner);
+	return alts.map((alt, index) => {
+		const use = buildUseHtml(id, viewBox, width, height, alt);
+		return index === 0 ? sprite + use : use;
+	});
+};
+// src/mermaid-pele.ts
+/** The class a fenced `mermaid` block's `<code>` takes. */
+const MERMAID_LANGUAGE_CLASS = `language-mermaid`;
+/** The class a `<pre>` holding a diagram written as HTML takes, as Mermaid reads it in the browser. */
+const MERMAID_PRE_CLASS = `mermaid`;
+const hash = (str) => {
+	let h = 2166136261;
+	for (let i = 0; i < str.length; i++) h = Math.imul(h ^ str.charCodeAt(i), 16777619) >>> 0;
+	return h.toString(36);
+};
+/** A diagram's source as Pele reads it: line endings normalized, as markdown-it already has them. */
+const mermaidSource = (text) => text.replace(/\r\n?/g, `\n`);
+/**
+* A document's id prefixes, one per diagram in document order: `prefix`, then a hash of the diagram's source, so a diagram's ids don't change when others are edited, with `-2`, `-3`… for repeats of one diagram. Pele namespaces every id it writes (an accessible title, a gradient) under it. Create one per document.
+*/
+const mermaidIdPrefixes = (prefix) => {
+	const seen = /* @__PURE__ */ new Map();
+	return (source) => {
+		const id = `${prefix}-${hash(source)}`;
+		const count = (seen.get(id) ?? 0) + 1;
+		seen.set(id, count);
+		return count === 1 ? id : `${id}-${count}`;
+	};
+};
+const escapeAttribute = (value) => value.replace(/&/g, `&amp;`).replace(/"/g, `&quot;`);
+const classes = (value) => value.split(/\s+/).filter((name) => name !== `` && name !== MERMAID_LANGUAGE_CLASS && name !== MERMAID_PRE_CLASS);
+/**
+* Pele's `<svg>` with the attributes the diagram's element had (from an attribute block such as `{#id .class}`): classes are added after Pele's, a style after Pele's (whose theme variables the diagram needs), and anything else is set, replacing Pele's value. The class that marked the element as a diagram is dropped.
+*/
+const mermaidSvg = (svg, attributes) => {
+	const open = /^<svg\b[^>]*>/.exec(svg)?.[0];
+	if (!open || attributes.length === 0) return svg;
+	const own = [...open.slice(4, -1).matchAll(/\s([^\s=]+)="([^"]*)"/g)].map(([, name = ``, value = ``]) => [name, value]);
+	const merged = new Map(own);
+	for (const [name, value] of attributes) {
+		const escaped = escapeAttribute(value);
+		const current = merged.get(name);
+		if (name === `class`) {
+			const added = classes(value).map(escapeAttribute).join(` `);
+			if (added) merged.set(name, current ? `${current} ${added}` : added);
+		} else if (name === `style` && current) merged.set(name, `${current.replace(/;$/, ``)};${escaped}`);
+		else merged.set(name, escaped);
+	}
+	return `<svg${[...merged].map(([name, value]) => ` ${name}="${value}"`).join(``)}>${svg.slice(open.length)}`;
+};
+/** A hast element's properties as attributes; `className` becomes `class`, and other names are kept as the attribute plugins write them. */
+const hastAttributes = (properties) => {
+	const text = (value) => typeof value === `string` ? value : typeof value === `number` ? String(value) : value === true ? `` : Array.isArray(value) ? value.map((item) => text(item) ?? ``).join(` `) : void 0;
+	const attributes = [];
+	for (const [key, value] of Object.entries(properties ?? {})) {
+		const written = text(value);
+		if (written !== void 0) attributes.push([key === `className` ? `class` : key, written]);
+	}
+	return attributes;
+};
+const hasClass = (node, name) => {
+	const value = node.properties?.className;
+	return Array.isArray(value) ? value.includes(name) : typeof value === `string` && value.split(/\s+/).includes(name);
+};
+const textOf = (node) => node.type === `text` ? node.value ?? `` : (node.children ?? []).map(textOf).join(``);
+/**
+* The diagram a `<pre>` holds, as rehype-mermaid finds them: a `<pre>` whose only content (besides whitespace) is a `<code class="language-mermaid">`, which is how a fenced `mermaid` block renders, or a `<pre class="mermaid">`. `element` is the one whose attributes the `<svg>` takes. `undefined` for anything else.
+*/
+const mermaidDiagram = (pre) => {
+	if (pre.tagName !== `pre`) return void 0;
+	if (hasClass(pre, MERMAID_PRE_CLASS)) return {
+		source: mermaidSource(textOf(pre)),
+		element: pre
+	};
+	let code;
+	for (const child of pre.children ?? []) {
+		if (child.type === `text` && /^\s*$/.test(child.value ?? ``)) continue;
+		if (code || child.tagName !== `code`) return void 0;
+		code = child;
+	}
+	return code && hasClass(code, MERMAID_LANGUAGE_CLASS) ? {
+		source: mermaidSource(textOf(code)),
+		element: code
+	} : void 0;
+};
+/**
+* The error a diagram that failed to render throws: Pele's message, at the document line Pele located the problem on (counting from `line`, the line the diagram's element starts on), or at `line` itself when Pele has no location. The original error is the `cause`.
+*/
+const mermaidFailure = (error, line) => {
+	const reason = error instanceof Error ? error.message : String(error);
+	const within = error instanceof Error && `line` in error && typeof error.line === `number` && error.line > 0 ? error.line : 0;
+	const at = line === void 0 ? `` : ` on line ${String(line + within)}`;
+	return new Error(`Could not render the mermaid diagram${at}: ${reason}`, { cause: error });
+};
+export { ALERT_ALIASES, CAPTION_CLASS, DEFAULT_TITLE, ICONS, LIGHTBOX_MARKER, containersKept, createAbbreviationScan, createAlertResolver, createDelimitedTransform, createKbdTransform, editableTree, escapedIndices, figureProperties, hastAttributes, headingRank, inlineSvgMarkup, isAlertMarkerLine, isCaptionFigure, isCaptionLine, isEmptyParagraph, isImageParagraph, itemColumns, lightboxDialog, lightboxId, lightboxTrigger, maskEscaped, maskTreeEscapes, mermaidDiagram, mermaidFailure, mermaidIdPrefixes, mermaidSource, mermaidSvg, parseAbbreviations, placeCutAttributes, plainText, processCaptions, processSteps, processStepsInChildren, processTabs, processTabsInChildren, scriptSyntax, sectionize, splitAlertParagraph, startsCaption, stripAttrs, stripCaptionMarker, svgSpriteId, tabLabelText, tabsBlockId, unmaskEscaped };
+
+//# sourceMappingURL=index.mjs.map