@farming-labs/docs 0.2.71 → 0.2.73

package/dist/markdown-rendering.mjs

@@ -0,0 +1,618 @@
+import { s as parseDocsMarkdownSections } from "./markdown-sections-7OoA7ylx.mjs";
+import { parseEntities } from "parse-entities";
+
+//#region src/markdown-rendering.ts
+const TRAILING_DOCS_MARKDOWN_HEADING_ID = /\s*\\?\[#([^\]\r\n]+)\]\s*$/;
+/**
+* Allocate transport placeholders without colliding with authored Markdown.
+*
+* Manual renderers restore these tokens after their inline/block passes, so a
+* collision would otherwise move rendered component HTML to user-authored text.
+*/
+function createDocsMarkdownBlockPlaceholderAllocator(source) {
+	const nextIndexes = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	return (kind) => {
+		let index = nextIndexes.get(kind) ?? 0;
+		let token = "";
+		do {
+			token = `%%${kind}_${index}%%`;
+			index += 1;
+		} while (source.includes(token) || used.has(token));
+		nextIndexes.set(kind, index);
+		used.add(token);
+		return token;
+	};
+}
+function createDocsMarkdownTransportToken(source, kind, index, used) {
+	let salt = 0;
+	let token = "";
+	do {
+		token = `\uE100FARMINGLABS_DOCS_${kind.toUpperCase()}_${index}_${salt}\uE101`;
+		salt += 1;
+	} while (source.includes(token) || used.has(token));
+	return token;
+}
+function createDocsMarkdownOpeningTagToken(source, index, used) {
+	let candidate = index;
+	let token = "";
+	do {
+		token = `%%FARMINGLABS_DOCS_HEADING_OPEN_${candidate}%%`;
+		candidate += 1;
+	} while (source.includes(token) || used.has(token));
+	return token;
+}
+function escapeDocsMarkdownHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function splitDocsMarkdownHeadingContainerLine(line) {
+	let prefix = "";
+	let content = line;
+	while (content) {
+		const container = content.match(/^(?: {0,3}>[\t ]?| {0,3}(?:[-+*]|\d{1,9}[.)])[\t ]+)/);
+		if (!container) break;
+		prefix += container[0];
+		content = content.slice(container[0].length);
+	}
+	return {
+		prefix,
+		content
+	};
+}
+/**
+* Annotate only headings accepted by the canonical section parser.
+*
+* The opaque tokens let the lightweight Astro, Nuxt, and Svelte renderers carry
+* exact IDs through their component and inline-Markdown passes without parsing
+* the document a second, divergent way.
+*/
+function prepareDocsMarkdownHeadings(markdown) {
+	const frontmatter = markdown.match(/^(\uFEFF?---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$))/)?.[1] ?? "";
+	const frontmatterLineOffset = frontmatter.match(/\r?\n/g)?.length ?? 0;
+	const canonicalHeadings = parseDocsMarkdownSections(frontmatter ? markdown.slice(frontmatter.length) : markdown);
+	const canonicalHeadingsByLine = new Map(canonicalHeadings.map((heading) => [heading.startLine + frontmatterLineOffset, heading]));
+	const headings = [];
+	const headingTokens = /* @__PURE__ */ new Set();
+	const output = [];
+	const annotate = (source, canonicalHeading) => {
+		const token = createDocsMarkdownTransportToken(markdown, "anchor", headings.length, headingTokens);
+		headingTokens.add(token);
+		headings.push({
+			anchor: canonicalHeading.anchor,
+			explicit: canonicalHeading.explicit,
+			level: canonicalHeading.level,
+			token
+		});
+		return `${source} ${token}`;
+	};
+	const lines = markdown.split(/\r?\n/);
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		const canonicalHeading = canonicalHeadingsByLine.get(index + 1);
+		if (!canonicalHeading) {
+			output.push(line);
+			continue;
+		}
+		const containerLine = splitDocsMarkdownHeadingContainerLine(line);
+		const atx = containerLine.content.match(/^ {0,3}(#{1,6})(?:[\t ]+|$)(.*)$/);
+		if (atx) {
+			const source = atx[2].replace(/[\t ]+#+[\t ]*$/, "").trim();
+			output.push(`${containerLine.prefix}${atx[1]} ${annotate(source, canonicalHeading)}`);
+			continue;
+		}
+		output.push(`${containerLine.prefix}${annotate(containerLine.content.trim(), canonicalHeading)}`);
+	}
+	return {
+		markdown: output.join("\n"),
+		headings
+	};
+}
+function stripPreparedDocsMarkdownHeadingTokens(value) {
+	return value;
+}
+function renderDocsMarkdownHeadings(markdown, preparedHeadings) {
+	const lines = markdown.split(/\r?\n/);
+	const output = [];
+	const openingTags = [];
+	const openingTagTokens = /* @__PURE__ */ new Set();
+	const protectOpeningTag = (level, anchor) => {
+		const token = createDocsMarkdownOpeningTagToken(markdown, openingTags.length, openingTagTokens);
+		openingTagTokens.add(token);
+		openingTags.push({
+			html: `<h${level} id="${escapeDocsMarkdownHtml(anchor)}">`,
+			token
+		});
+		return token;
+	};
+	const resolveHeading = (source) => {
+		const prepared = preparedHeadings.find((heading) => source.includes(heading.token));
+		if (!prepared) return void 0;
+		const withoutToken = source.split(prepared.token).join("");
+		return {
+			anchor: prepared.anchor,
+			explicit: prepared.explicit,
+			level: prepared.level,
+			source: prepared.explicit ? withoutToken.replace(TRAILING_DOCS_MARKDOWN_HEADING_ID, "").trim() : withoutToken.trim()
+		};
+	};
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		const containerLine = splitDocsMarkdownHeadingContainerLine(line);
+		const atx = containerLine.content.match(/^ {0,3}(#{1,6})(?:[\t ]+|$)(.*)$/);
+		if (atx) {
+			const heading = resolveHeading(atx[2].replace(/[\t ]+#+[\t ]*$/, "").trim());
+			if (!heading) {
+				output.push(line);
+				continue;
+			}
+			const level = atx[1].length;
+			output.push(`${containerLine.prefix}${protectOpeningTag(level, heading.anchor)}${heading.source}</h${level}>`);
+			continue;
+		}
+		const heading = resolveHeading(containerLine.content.trim());
+		if (heading) {
+			const sourceLines = [heading.source];
+			let underlineIndex = index + 1;
+			const expectedUnderline = heading.level === 1 ? /^=+$/ : /^-+$/;
+			while (underlineIndex < lines.length) {
+				const continuation = splitDocsMarkdownHeadingContainerLine(lines[underlineIndex] ?? "").content;
+				if (expectedUnderline.test(continuation.trim())) break;
+				if (!continuation.trim()) break;
+				sourceLines.push(continuation.trim());
+				underlineIndex += 1;
+			}
+			const combinedSource = sourceLines.join(" ");
+			const visibleSource = heading.explicit ? combinedSource.replace(TRAILING_DOCS_MARKDOWN_HEADING_ID, "").trim() : combinedSource;
+			output.push(`${containerLine.prefix}${protectOpeningTag(heading.level, heading.anchor)}${visibleSource}</h${heading.level}>`);
+			if (underlineIndex < lines.length) index = underlineIndex;
+			continue;
+		}
+		output.push(line);
+	}
+	let renderedMarkdown = output.join("\n");
+	for (const prepared of preparedHeadings) renderedMarkdown = renderedMarkdown.split(prepared.token).join("");
+	return {
+		markdown: renderedMarkdown,
+		openingTags
+	};
+}
+function restoreDocsMarkdownHeadingOpeningTags(value, openingTags) {
+	let restored = value;
+	for (const openingTag of openingTags) restored = restored.split(openingTag.token).join(openingTag.html);
+	return restored;
+}
+function splitDocsMarkdownFenceContainerLine(line) {
+	const containers = [];
+	let content = line;
+	let prefix = "";
+	while (content) {
+		const blockquote = content.match(/^ {0,3}>[\t ]?/);
+		if (blockquote) {
+			prefix += blockquote[0];
+			content = content.slice(blockquote[0].length);
+			containers.push({
+				continuationIndent: 0,
+				type: "blockquote"
+			});
+			continue;
+		}
+		const listItem = content.match(/^ {0,3}(?:[-+*]|\d{1,9}[.)])[\t ]+/);
+		if (listItem) {
+			prefix += listItem[0];
+			content = content.slice(listItem[0].length);
+			containers.push({
+				continuationIndent: listItem[0].length,
+				type: "list"
+			});
+			continue;
+		}
+		break;
+	}
+	return {
+		containers,
+		content,
+		prefix
+	};
+}
+function continueDocsMarkdownFenceContainerLine(line, containers) {
+	let content = line;
+	for (const container of containers) {
+		if (container.type === "blockquote") {
+			const blockquote = content.match(/^ {0,3}>[\t ]?/);
+			if (!blockquote) return void 0;
+			content = content.slice(blockquote[0].length);
+			continue;
+		}
+		if (!content.trim()) {
+			content = "";
+			continue;
+		}
+		const indentation = content.match(/^[\t ]*/)?.[0] ?? "";
+		if (indentation.replace(/\t/g, "    ").length < container.continuationIndent) return void 0;
+		let consumedLength = 0;
+		let consumedWidth = 0;
+		while (consumedLength < indentation.length) {
+			consumedWidth += indentation[consumedLength] === "	" ? 4 : 1;
+			consumedLength += 1;
+			if (consumedWidth >= container.continuationIndent) break;
+		}
+		content = content.slice(consumedLength);
+	}
+	return content;
+}
+/**
+* Replace complete CommonMark fenced code blocks without confusing shorter
+* marker runs inside a longer outer fence for its closing delimiter.
+*/
+function replaceDocsMarkdownFencedCodeBlocks(value, render) {
+	const lines = [];
+	for (const match of value.matchAll(/[^\r\n]*(?:\r\n|\n|\r|$)/g)) {
+		const raw = match[0];
+		if (!raw) continue;
+		const ending = raw.match(/(?:\r\n|\n|\r)$/)?.[0] ?? "";
+		const start = match.index;
+		const end = start + raw.length - ending.length;
+		lines.push({
+			end,
+			ending,
+			start,
+			text: ending ? raw.slice(0, -ending.length) : raw
+		});
+	}
+	let blockIndex = 0;
+	let cursor = 0;
+	let output = "";
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+		const openingLine = lines[lineIndex];
+		const containerLine = splitDocsMarkdownFenceContainerLine(openingLine.text);
+		const opening = containerLine.content.match(/^( {0,3})(`{3,}|~{3,})([^\r\n]*)$/);
+		if (!opening) continue;
+		const marker = opening[2][0];
+		const info = opening[3].trim();
+		if (marker === "`" && info.includes("`")) continue;
+		const codeLines = [];
+		let closingIndex = lineIndex + 1;
+		for (; closingIndex < lines.length; closingIndex += 1) {
+			const continuedContent = containerLine.containers.length === 0 ? lines[closingIndex].text : continueDocsMarkdownFenceContainerLine(lines[closingIndex].text, containerLine.containers);
+			if (continuedContent === void 0) break;
+			const closing = continuedContent.match(/^ {0,3}(`+|~+)[\t ]*$/);
+			if (closing && closing[1][0] === marker && closing[1].length >= opening[2].length) break;
+			codeLines.push(`${continuedContent}${lines[closingIndex].ending}`);
+		}
+		const candidateClosingLine = lines[closingIndex];
+		const candidateClosing = (candidateClosingLine ? containerLine.containers.length === 0 ? candidateClosingLine.text : continueDocsMarkdownFenceContainerLine(candidateClosingLine.text, containerLine.containers) : void 0)?.match(/^ {0,3}(`+|~+)[\t ]*$/);
+		const closingLine = candidateClosing && candidateClosing[1][0] === marker && candidateClosing[1].length >= opening[2].length ? candidateClosingLine : void 0;
+		const implicitClosingLine = candidateClosingLine ? lines[closingIndex - 1] : void 0;
+		const blockEnd = closingLine?.end ?? implicitClosingLine?.end ?? value.length;
+		output += value.slice(cursor, openingLine.start);
+		output += containerLine.prefix + opening[1];
+		output += render({
+			code: codeLines.join(""),
+			fenceLength: opening[2].length,
+			info,
+			marker
+		}, blockIndex);
+		blockIndex += 1;
+		cursor = blockEnd;
+		if (closingLine) lineIndex = closingIndex;
+		else if (candidateClosingLine) lineIndex = closingIndex - 1;
+		else break;
+	}
+	return blockIndex === 0 ? value : output + value.slice(cursor);
+}
+function normalizeDocsMarkdownReferenceLabel(value) {
+	return parseEntities(unescapeDocsMarkdownPunctuation(value), { nonTerminated: false }).trim().replace(/\s+/g, " ").toLowerCase();
+}
+function unescapeDocsMarkdownPunctuation(value) {
+	return value.replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~])/g, "$1");
+}
+function findDocsMarkdownClosingDelimiter(value, start, open, close) {
+	let depth = 0;
+	for (let index = start; index < value.length; index += 1) {
+		if (value[index] === "\\") {
+			index += 1;
+			continue;
+		}
+		if (value[index] === open) depth += 1;
+		if (value[index] !== close) continue;
+		depth -= 1;
+		if (depth === 0) return index;
+	}
+	return -1;
+}
+function readDocsMarkdownHtmlTagEnd(value, start) {
+	if (value[start] !== "<" || !/[A-Za-z/!?]/.test(value[start + 1] ?? "")) return -1;
+	let quote;
+	for (let index = start + 1; index < value.length; index += 1) {
+		const character = value[index];
+		if (quote) {
+			if (character === quote && value[index - 1] !== "\\") quote = void 0;
+			continue;
+		}
+		if (character === "'" || character === "\"") {
+			quote = character;
+			continue;
+		}
+		if (character === ">") return index;
+	}
+	return -1;
+}
+function parseDocsMarkdownDestination(source) {
+	const value = source.trim();
+	if (!value) return { destination: "" };
+	let destination = "";
+	let remainder = "";
+	if (value.startsWith("<")) {
+		const end = value.indexOf(">");
+		if (end < 0) return void 0;
+		destination = value.slice(1, end);
+		remainder = value.slice(end + 1).trim();
+	} else {
+		let depth = 0;
+		let end = value.length;
+		for (let index = 0; index < value.length; index += 1) {
+			if (value[index] === "\\") {
+				index += 1;
+				continue;
+			}
+			if (value[index] === "(") depth += 1;
+			if (value[index] === ")") depth = Math.max(0, depth - 1);
+			if (/\s/.test(value[index]) && depth === 0) {
+				end = index;
+				break;
+			}
+		}
+		destination = value.slice(0, end);
+		remainder = value.slice(end).trim();
+	}
+	let title;
+	if (remainder) {
+		const titleMatch = remainder.match(/^(?:"([^"]*)"|'([^']*)'|\(([^()]*)\))$/);
+		if (!titleMatch) return void 0;
+		title = titleMatch[1] ?? titleMatch[2] ?? titleMatch[3];
+	}
+	return {
+		destination: unescapeDocsMarkdownPunctuation(destination),
+		...title === void 0 ? {} : { title: unescapeDocsMarkdownPunctuation(title) }
+	};
+}
+function extractDocsMarkdownReferenceDefinitions(markdown) {
+	const definitions = /* @__PURE__ */ new Map();
+	const output = [];
+	let openFence;
+	for (const line of markdown.split(/\r?\n/)) {
+		if (openFence) {
+			const marker = openFence.marker === "`" ? "`" : "~";
+			if (new RegExp(`^ {0,3}${marker}{${openFence.length},}[\\t ]*$`).test(line)) openFence = void 0;
+			output.push(line);
+			continue;
+		}
+		const openingFence = line.match(/^ {0,3}(`{3,}|~{3,})/);
+		if (openingFence) {
+			openFence = {
+				marker: openingFence[1][0],
+				length: openingFence[1].length
+			};
+			output.push(line);
+			continue;
+		}
+		const definitionMatch = line.match(/^ {0,3}\[([^\]]+)\]:[ \t]*(.*)$/);
+		const definition = definitionMatch ? parseDocsMarkdownDestination(definitionMatch[2]) : void 0;
+		if (!definitionMatch || !definition) {
+			output.push(line);
+			continue;
+		}
+		const normalizedLabel = normalizeDocsMarkdownReferenceLabel(definitionMatch[1]);
+		if (!definitions.has(normalizedLabel)) definitions.set(normalizedLabel, definition);
+		output.push("");
+	}
+	return {
+		markdown: output.join("\n"),
+		definitions
+	};
+}
+function renderDocsMarkdownResources(value, definitions) {
+	let output = "";
+	let index = 0;
+	while (index < value.length) {
+		const htmlTagEnd = readDocsMarkdownHtmlTagEnd(value, index);
+		if (htmlTagEnd >= 0) {
+			output += value.slice(index, htmlTagEnd + 1);
+			index = htmlTagEnd + 1;
+			continue;
+		}
+		const image = value[index] === "!" && value[index + 1] === "[";
+		const link = value[index] === "[";
+		if (!image && !link) {
+			output += value[index];
+			index += 1;
+			continue;
+		}
+		const labelStart = index + (image ? 2 : 1);
+		const labelEnd = findDocsMarkdownClosingDelimiter(value, labelStart - 1, "[", "]");
+		if (labelEnd < 0) {
+			output += value[index];
+			index += 1;
+			continue;
+		}
+		const label = value.slice(labelStart, labelEnd);
+		let end = labelEnd + 1;
+		let target;
+		if (value[end] === "(") {
+			const destinationEnd = findDocsMarkdownClosingDelimiter(value, end, "(", ")");
+			if (destinationEnd < 0) {
+				output += value[index];
+				index += 1;
+				continue;
+			}
+			target = parseDocsMarkdownDestination(value.slice(end + 1, destinationEnd));
+			end = destinationEnd + 1;
+		} else if (value[end] === "[") {
+			const referenceEnd = findDocsMarkdownClosingDelimiter(value, end, "[", "]");
+			if (referenceEnd < 0) {
+				output += value[index];
+				index += 1;
+				continue;
+			}
+			const referenceLabel = value.slice(end + 1, referenceEnd) || label;
+			target = definitions.get(normalizeDocsMarkdownReferenceLabel(referenceLabel));
+			end = referenceEnd + 1;
+		} else target = definitions.get(normalizeDocsMarkdownReferenceLabel(label));
+		if (!target) {
+			output += value.slice(index, end);
+			index = end;
+			continue;
+		}
+		const titleAttribute = target.title === void 0 ? "" : ` title="${escapeDocsMarkdownHtml(target.title)}"`;
+		if (image) {
+			const alt = unescapeDocsMarkdownPunctuation(label).replace(/<[^>]+>/g, "").replace(/[*_~`]/g, "");
+			output += `<img src="${escapeDocsMarkdownHtml(target.destination)}" alt="${escapeDocsMarkdownHtml(alt)}" class="fd-docs-content-img" loading="lazy" decoding="async"${titleAttribute} />`;
+		} else output += `<a href="${escapeDocsMarkdownHtml(target.destination)}"${titleAttribute}>${renderDocsMarkdownResources(label, definitions)}</a>`;
+		index = end;
+	}
+	return output;
+}
+function renderDocsMarkdownEmphasis(value) {
+	return value.replace(/\*\*\*(.+?)\*\*\*/g, "<strong><em>$1</em></strong>").replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/(?<![\w])__([^_\n]+)__(?![\w])/g, "<strong>$1</strong>").replace(/\*([^*\n]+)\*/g, "<em>$1</em>").replace(/(?<![\w])_([^_\n]+)_(?![\w])/g, "<em>$1</em>").replace(/~~([^~\n]+)~~/g, "<del>$1</del>");
+}
+function renderDocsMarkdownTextOutsideHtml(value) {
+	let output = "";
+	let textStart = 0;
+	let index = 0;
+	while (index < value.length) {
+		const htmlTagEnd = readDocsMarkdownHtmlTagEnd(value, index);
+		if (htmlTagEnd < 0) {
+			index += 1;
+			continue;
+		}
+		output += renderDocsMarkdownEmphasis(value.slice(textStart, index));
+		output += value.slice(index, htmlTagEnd + 1);
+		index = htmlTagEnd + 1;
+		textStart = index;
+	}
+	output += renderDocsMarkdownEmphasis(value.slice(textStart));
+	return output;
+}
+function renderDocsMarkdownInline(value, definitions) {
+	const literals = [];
+	const literalTokens = /* @__PURE__ */ new Set();
+	const protectLiteral = (html) => {
+		const token = createDocsMarkdownTransportToken(value, "inline", literals.length, literalTokens);
+		literalTokens.add(token);
+		literals.push({
+			html,
+			token
+		});
+		return token;
+	};
+	let protectedValue = value.replace(/(`+)([\s\S]*?)\1/g, (_match, _ticks, code) => {
+		const normalized = code.replace(/\s+/g, " ");
+		return protectLiteral(`<code>${escapeDocsMarkdownHtml(normalized.length > 2 && normalized.startsWith(" ") && normalized.endsWith(" ") && normalized.trim() ? normalized.slice(1, -1) : normalized)}</code>`);
+	});
+	protectedValue = protectedValue.replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~])/g, (_match, punctuation) => protectLiteral(escapeDocsMarkdownHtml(punctuation)));
+	let rendered = renderDocsMarkdownTextOutsideHtml(renderDocsMarkdownResources(protectedValue, definitions));
+	for (const literal of literals) rendered = rendered.split(literal.token).join(literal.html);
+	return rendered;
+}
+function renderDocsMarkdownBlockContent(value, definitions) {
+	const output = [];
+	let paragraphLines = [];
+	const flushParagraph = () => {
+		if (paragraphLines.length === 0) return;
+		output.push(`<p>${paragraphLines.map((line) => renderDocsMarkdownInline(line, definitions)).join("<br />")}</p>`);
+		paragraphLines = [];
+	};
+	for (const line of value.trim().split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			flushParagraph();
+			continue;
+		}
+		const heading = trimmed.match(/^<h([1-6])\b([^>]*)>([\s\S]*)<\/h\1>$/);
+		if (heading) {
+			flushParagraph();
+			output.push(`<h${heading[1]}${heading[2]}>${renderDocsMarkdownInline(heading[3], definitions)}</h${heading[1]}>`);
+			continue;
+		}
+		if (/^<(?:pre|ul|ol|blockquote|hr|table|div|figure)\b/.test(trimmed)) {
+			flushParagraph();
+			output.push(trimmed);
+			continue;
+		}
+		if (/^%%(?:CODEBLOCK|CALLOUT|TABS|PROMPT|HOVERLINK)_\d+%%$/.test(trimmed)) {
+			flushParagraph();
+			output.push(trimmed);
+			continue;
+		}
+		paragraphLines.push(trimmed);
+	}
+	flushParagraph();
+	return output.join("");
+}
+/**
+* Hoist canonical headings out of component bodies before those bodies are
+* rendered as cards, tabs, or literal prompt text.
+*
+* A heading must still carry an opening-tag transport token created by
+* `renderDocsMarkdownHeadings`. Authored raw `<h*>` HTML is deliberately left
+* in `content`, so a literal renderer such as Prompt can escape it instead of
+* accidentally promoting its attributes to live HTML.
+*/
+function extractDocsRenderedHeadingElements(value, definitions, preserveText = true, openingTags = []) {
+	const headings = [];
+	const output = [];
+	const protectedHeadings = openingTags.flatMap((openingTag) => {
+		const level = openingTag.html.match(/^<h([1-6])\b[^>]*>$/)?.[1];
+		return level ? [{
+			...openingTag,
+			level
+		}] : [];
+	});
+	let openFence;
+	for (const lineWithEnding of value.match(/[^\r\n]*(?:\r\n|\n|\r|$)/g) ?? []) {
+		if (!lineWithEnding) continue;
+		const ending = lineWithEnding.match(/(?:\r\n|\n|\r)$/)?.[0] ?? "";
+		const line = ending ? lineWithEnding.slice(0, -ending.length) : lineWithEnding;
+		if (openFence) {
+			const continuedContent = openFence.containers.length === 0 ? line : continueDocsMarkdownFenceContainerLine(line, openFence.containers);
+			if (continuedContent !== void 0) {
+				output.push(lineWithEnding);
+				const marker = openFence.marker === "`" ? "`" : "~";
+				if (new RegExp(`^ {0,3}${marker}{${openFence.length},}[\\t ]*$`).test(continuedContent)) openFence = void 0;
+				continue;
+			}
+			openFence = void 0;
+		}
+		const containerLine = splitDocsMarkdownFenceContainerLine(line);
+		const openingFence = containerLine.content.match(/^ {0,3}(`{3,}|~{3,})/);
+		if (openingFence) {
+			openFence = {
+				containers: containerLine.containers,
+				length: openingFence[1].length,
+				marker: openingFence[1][0]
+			};
+			output.push(lineWithEnding);
+			continue;
+		}
+		let renderedLine = line;
+		for (const protectedHeading of protectedHeadings) {
+			const tokenIndex = renderedLine.indexOf(protectedHeading.token);
+			if (tokenIndex < 0) continue;
+			const contentStart = tokenIndex + protectedHeading.token.length;
+			const closingTag = `</h${protectedHeading.level}>`;
+			const contentEnd = renderedLine.indexOf(closingTag, contentStart);
+			if (contentEnd < 0) continue;
+			const inner = renderedLine.slice(contentStart, contentEnd);
+			headings.push(`${protectedHeading.html}${renderDocsMarkdownInline(inner, definitions)}${closingTag}`);
+			renderedLine = renderedLine.slice(0, tokenIndex) + (preserveText ? inner.replace(/<[^>]+>/g, "").trim() : "") + renderedLine.slice(contentEnd + closingTag.length);
+		}
+		output.push(`${renderedLine}${ending}`);
+	}
+	return {
+		headingsHtml: headings.join("\n"),
+		content: output.join("")
+	};
+}
+
+//#endregion
+export { createDocsMarkdownBlockPlaceholderAllocator, extractDocsMarkdownReferenceDefinitions, extractDocsRenderedHeadingElements, prepareDocsMarkdownHeadings, renderDocsMarkdownBlockContent, renderDocsMarkdownHeadings, renderDocsMarkdownInline, replaceDocsMarkdownFencedCodeBlocks, restoreDocsMarkdownHeadingOpeningTags, stripPreparedDocsMarkdownHeadingTokens };