@mirrordown/core 0.0.0 → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1818 @@
+// 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 = /^\[!([^\]]+)\]([+-])?/;
+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$2 = /^[\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$2.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$1 = /\s/;
+const classify = (code) => code === null || code < 0 || code === 32 || WHITESPACE$1.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/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. */
+const lightboxDialog = (id, image) => ({
+	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]
+	}]
+});
+// 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/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;
+};
+// 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);
+		for (const [index, lineSegs] of lines.entries()) {
+			const header = stepHeader(lineSegs);
+			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) => {
+	const newChildren = [];
+	let i = 0;
+	while (i < children.length) {
+		const node = children[i];
+		if (!node) break;
+		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 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;
+				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) => {
+		if (!Array.isArray(node.children) || node.children.length === 0) return;
+		processStepsInChildren(node.children, containerClass, sourceLines);
+		for (const child of node.children) walk(child);
+	};
+	processStepsInChildren(root.children, containerClass, sourceLines);
+	for (const child of root.children) walk(child);
+};
+// 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 splitLines = (lines, markersOf, para) => {
+		let bodyLines = [];
+		for (const [index, lineSegs] of lines.entries()) {
+			const first = lineSegs[0];
+			if (first?.type === "text") {
+				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) => {
+	const newChildren = [];
+	let i = 0;
+	while (i < children.length) {
+		const node = children[i];
+		if (!node) break;
+		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) => {
+		if (!Array.isArray(node.children) || node.children.length === 0) return;
+		processTabsInChildren(node.children, containerClass, false, sourceLines);
+		for (const child of node.children) walk(child);
+	};
+	processTabsInChildren(root.children, containerClass, true, sourceLines);
+	for (const child of root.children) walk(child);
+};
+// 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 = (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(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;
+	});
+};
+export { ALERT_ALIASES, DEFAULT_TITLE, ICONS, LIGHTBOX_MARKER, createAbbreviationScan, createAlertResolver, createDelimitedTransform, createKbdTransform, editableTree, escapedIndices, headingRank, inlineSvgMarkup, isEmptyParagraph, isImageParagraph, lightboxDialog, lightboxId, lightboxTrigger, maskEscaped, maskTreeEscapes, parseAbbreviations, placeCutAttributes, plainText, processSteps, processStepsInChildren, processTabs, processTabsInChildren, scriptSyntax, sectionize, splitAlertParagraph, stripAttrs, svgSpriteId, tabLabelText, tabsBlockId, unmaskEscaped };
+
+//# sourceMappingURL=index.mjs.map