@mirrordown/core 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -133,6 +133,8 @@ const ICONS = {
 };
 // 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 = {}) => {
@@ -244,9 +246,9 @@ const INLINE_PARENTS = /* @__PURE__ */ new Set([
 	`subscript`,
 	`superscript`
 ]);
-const WHITESPACE$2 = /^[\t\n\v\f\r \u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]$/u;
+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$2.test(char) ? `space` : PUNCTUATION$1.test(char) ? `punct` : `other`;
+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.
 */
@@ -484,8 +486,8 @@ 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 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));
@@ -603,156 +605,6 @@ const scriptSyntax = (marker) => {
 		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();
@@ -955,6 +807,492 @@ const rebuildLazyLines = (lines, level) => {
 	}
 	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) => {
@@ -1111,8 +1449,10 @@ const splitBlockquote$1 = (bq, counters, currentDepth, sourceLines) => {
 		}
 		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 = stepHeader(lineSegs);
+			const header = outsideBody(index) ? stepHeader(lineSegs) : null;
 			if (header) {
 				const bodyPara = linesToParagraph(bodyLines);
 				if (bodyPara) currentSegment.body.push(bodyPara);
@@ -1168,12 +1508,19 @@ const buildTree$1 = (steps, targetDepth, start, end) => {
 		data: { attrsRole: "container" }
 	};
 };
-const processStepsInChildren = (children, containerClass, sourceLines) => {
+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);
@@ -1189,6 +1536,8 @@ const processStepsInChildren = (children, containerClass, sourceLines) => {
 					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);
@@ -1221,6 +1570,7 @@ const processStepsInChildren = (children, containerClass, sourceLines) => {
 				}
 				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;
@@ -1237,13 +1587,15 @@ const processStepsInChildren = (children, containerClass, sourceLines) => {
 */
 const processSteps = (root, containerClass, source) => {
 	const sourceLines = source?.split(/\r?\n/);
-	const walk = (node) => {
+	const walk = (node, quotes) => {
 		if (!Array.isArray(node.children) || node.children.length === 0) return;
-		processStepsInChildren(node.children, containerClass, sourceLines);
-		for (const child of node.children) walk(child);
+		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);
+	for (const child of root.children) walk(child, 0);
+	if (sourceLines) endGroupsAtMarkers(root, sourceLines, `stepsList`);
 };
 // src/tabs.ts
 const TAB_HEADER_RE = /^(%{1,6})(\+)? (.*)/;
@@ -1399,11 +1751,13 @@ const splitBlockquote = (bq, explicit, sourceLines) => {
 		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];
-			if (first?.type === "text") {
+			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) {
@@ -1568,12 +1922,19 @@ const buildTree = (rawTabs, targetDepth, start, end, containerClass) => {
 		}
 	};
 };
-const processTabsInChildren = (children, containerClass, checkBlankLines = true, sourceLines) => {
+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) {
@@ -1719,13 +2080,15 @@ const processTabsInChildren = (children, containerClass, checkBlankLines = true,
 */
 const processTabs = (root, containerClass, source) => {
 	const sourceLines = source?.split(/\r?\n/);
-	const walk = (node) => {
+	const walk = (node, quotes) => {
 		if (!Array.isArray(node.children) || node.children.length === 0) return;
-		processTabsInChildren(node.children, containerClass, false, sourceLines);
-		for (const child of node.children) walk(child);
+		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);
+	for (const child of root.children) walk(child, 0);
+	if (sourceLines) endGroupsAtMarkers(root, sourceLines, `tabsList`);
 };
 // src/editable.ts
 const editableTree = (root, build, setChildren, setData) => {
@@ -1765,7 +2128,7 @@ const editableTree = (root, build, setChildren, setData) => {
 	};
 };
 // src/inline-svg.ts
-const hash = (str) => {
+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);
@@ -1773,7 +2136,7 @@ const hash = (str) => {
 /**
 * 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 svgSpriteId = (relativePath) => `svg-sprite-${hash$1(relativePath)}`;
 const extractSvgParts = (content) => {
 	const openTag = /<svg([^>]*?)>/i.exec(content)?.[1] ?? ``;
 	return {
@@ -1813,6 +2176,95 @@ const inlineSvgMarkup = (content, alts, relativePath, limits) => {
 		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 };
+// 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