markdown-codec 11.1.12 → 11.1.14

package/dist/emit-CCOoudJW.cjs

@@ -0,0 +1,734 @@
+const require_diagnostics_diagnostics = require("./diagnostics/diagnostics.cjs");
+const require_inline_footnote = require("./inline/footnote.cjs");
+const require_shared_line_ending = require("./shared/line-ending.cjs");
+require("./defaults/defaults.cjs");
+const require_shared_style_constants = require("./shared/style-constants.cjs");
+const require_shared_list_id = require("./shared/list-id.cjs");
+const require_emit_front_matter = require("./emit/front-matter.cjs");
+const require_emit_inline = require("./emit/inline.cjs");
+const require_emit_image = require("./emit/image.cjs");
+const require_emit_table = require("./emit/table.cjs");
+const require_emit_setext = require("./emit/setext.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/emit/list-render.ts
+function listInfoFor(numId, context) {
+	if (numId === void 0) {
+		if (!context.reportedAbsentNumIdFallback) {
+			context.reportedAbsentNumIdFallback = true;
+			context.sink({
+				code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.LIST_NUMID_FALLBACK,
+				severity: "info",
+				message: "a list membership with no numId of its own (a depth-only ContentListMembership) has no marker type, task-ness, or loose-ness to recover and falls back to an ordinary, tight, non-task bullet list"
+			});
+		}
+		return;
+	}
+	const info = require_shared_list_id.parseListNumId(numId);
+	if (info === void 0 && !context.reportedFallbackNumIds.has(numId)) {
+		context.reportedFallbackNumIds.add(numId);
+		context.sink({
+			code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.LIST_NUMID_FALLBACK,
+			severity: "info",
+			message: `numId "${numId}" was not minted by this package's own src/lower and falls back to an ordinary, tight, non-task bullet list`
+		});
+	}
+	return info;
+}
+function stripCheckboxRun(item) {
+	const first = item.runs[0];
+	const glyphPrefix = first?.text.startsWith(`☒ `) === true ? `☒ ` : `☐ `;
+	if (first?.text.startsWith(glyphPrefix) !== true) return item;
+	const strippedText = first.text.slice(glyphPrefix.length);
+	const runs = strippedText.length === 0 ? item.runs.slice(1) : [{
+		...first,
+		text: strippedText
+	}, ...item.runs.slice(1)];
+	return {
+		...item,
+		runs
+	};
+}
+function toEmitItem(item) {
+	return item.kind === "paragraph" ? { block: item.block } : item.item;
+}
+function firstBlockCheckbox(first, taskNumId) {
+	if (first.list.checked !== void 0) return {
+		checkboxText: first.list.checked ? "[x] " : "[ ] ",
+		strippedFirstBlock: void 0
+	};
+	if (!taskNumId || first.kind !== "paragraph") return {
+		checkboxText: "",
+		strippedFirstBlock: void 0
+	};
+	const leading = first.block.runs[0]?.text;
+	if (leading?.startsWith(`☒ `) === true) return {
+		checkboxText: "[x] ",
+		strippedFirstBlock: stripCheckboxRun(first.block)
+	};
+	if (leading?.startsWith(`☐ `) === true) return {
+		checkboxText: "[ ] ",
+		strippedFirstBlock: stripCheckboxRun(first.block)
+	};
+	return {
+		checkboxText: "",
+		strippedFirstBlock: void 0
+	};
+}
+function renderListItemMarker(numId, info, glyph, checkboxText, context) {
+	if (info?.type === "ordered" && numId !== void 0) {
+		const next = context.orderedCounters.get(numId) ?? info.start ?? 1;
+		context.orderedCounters.set(numId, next + 1);
+		const bare = `${String(next)}${glyph} `;
+		return {
+			full: `${bare}${checkboxText}`,
+			bareLength: bare.length
+		};
+	}
+	const bare = `${glyph} `;
+	return {
+		full: `${bare}${checkboxText}`,
+		bareLength: bare.length
+	};
+}
+const BULLET_GLYPH_CANDIDATES = [
+	"-",
+	"+",
+	"*"
+];
+const ORDERED_GLYPH_CANDIDATES = [".", ")"];
+function resolveListGlyph(numId, type, previousSibling, context) {
+	const cached = context.resolvedListGlyphs.get(numId);
+	if (cached !== void 0) return cached;
+	const defaultGlyph = type === "ordered" ? context.orderedDelimiter : context.bulletMarker;
+	const glyph = previousSibling?.type === type && previousSibling.glyph === defaultGlyph ? (type === "ordered" ? ORDERED_GLYPH_CANDIDATES : BULLET_GLYPH_CANDIDATES).find((candidate) => candidate !== defaultGlyph) ?? defaultGlyph : defaultGlyph;
+	context.resolvedListGlyphs.set(numId, glyph);
+	return glyph;
+}
+function consumeSameItemRun(items, from, level, itemId) {
+	let end = from;
+	for (;;) {
+		const candidate = items[end];
+		if (candidate?.list.level !== level || candidate.list.itemId !== itemId) break;
+		end += 1;
+	}
+	return end;
+}
+function collectListItem(items, start, level, itemId) {
+	const segments = [];
+	let index = start;
+	const ownEnd = itemId === void 0 ? index + 1 : consumeSameItemRun(items, index, level, itemId);
+	segments.push({
+		kind: "own",
+		blocks: items.slice(index, ownEnd)
+	});
+	index = ownEnd;
+	for (;;) {
+		let nestedEnd = index;
+		for (;;) {
+			const candidateLevel = items[nestedEnd]?.list.level;
+			if (candidateLevel === void 0 || candidateLevel <= level) break;
+			nestedEnd += 1;
+		}
+		if (nestedEnd === index) break;
+		segments.push({
+			kind: "nested",
+			blocks: items.slice(index, nestedEnd)
+		});
+		index = nestedEnd;
+		if (itemId === void 0) break;
+		const resumedEnd = consumeSameItemRun(items, index, level, itemId);
+		segments.push({
+			kind: "own",
+			blocks: items.slice(index, resumedEnd)
+		});
+		index = resumedEnd;
+	}
+	return {
+		segments,
+		next: index
+	};
+}
+function emitItemCanInterrupt(item, context) {
+	if (!isConstructItem(item)) return item.block.kind === "paragraph" ? canInterruptOpenParagraph(item.block, context) : true;
+	if (isMaterialisedDivision(item)) return true;
+	const first = item.children[0];
+	return first === void 0 ? true : emitItemCanInterrupt(first, context);
+}
+function lastStyleIdOf(item) {
+	if (isConstructItem(item)) {
+		const last = item.children[item.children.length - 1];
+		return last === void 0 ? void 0 : lastStyleIdOf(last);
+	}
+	return item.block.kind === "paragraph" ? item.block.styleId : void 0;
+}
+function regionItemCanInterrupt(item, context) {
+	return emitItemCanInterrupt(toEmitItem(item), context);
+}
+function lastStyleIdOfRegionItem(item) {
+	return lastStyleIdOf(toEmitItem(item));
+}
+function listRegionItemBody(item, context, overrideParagraph) {
+	if (item.kind === "paragraph") return renderParagraphBody(overrideParagraph ?? item.block, context);
+	const previousEnclosingItemId = context.enclosingItemId;
+	context.enclosingItemId = item.list.itemId;
+	const body = renderConstruct(item.item, context);
+	context.enclosingItemId = previousEnclosingItemId;
+	return body;
+}
+function requiresBlankLineBefore(next, previousStyleId, context) {
+	if (previousStyleId === "HTMLPreformatted") return true;
+	return !require_emit_setext.terminatesCleanly(previousStyleId) && !regionItemCanInterrupt(next, context);
+}
+function renderListRegion(items, context) {
+	const parts = [];
+	let index = 0;
+	let previousSibling;
+	for (;;) {
+		const item = items[index];
+		if (item === void 0) break;
+		const { numId, level, itemId } = item.list;
+		const info = listInfoFor(numId, context);
+		const loose = info?.loose === true;
+		const type = info?.type ?? "bullet";
+		const glyph = numId === void 0 ? context.bulletMarker : resolveListGlyph(numId, type, previousSibling, context);
+		if (numId !== void 0) previousSibling = {
+			numId,
+			type,
+			glyph
+		};
+		const { segments, next } = collectListItem(items, index, level, itemId);
+		const first = segments[0]?.blocks[0];
+		if (first === void 0) break;
+		const { checkboxText, strippedFirstBlock } = firstBlockCheckbox(first, info?.task === true);
+		const marker = renderListItemMarker(numId, info, glyph, checkboxText, context);
+		const indent = " ".repeat(marker.bareLength);
+		let text = marker.full;
+		let renderedFirstLine = false;
+		let previousStyleId;
+		for (const segment of segments) {
+			if (segment.kind === "nested") {
+				const nested = renderListRegion(segment.blocks, context).split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
+				text += `\n${nested}`;
+				const lastNested = segment.blocks[segment.blocks.length - 1];
+				previousStyleId = lastNested === void 0 ? void 0 : lastStyleIdOfRegionItem(lastNested);
+				continue;
+			}
+			for (const block of segment.blocks) {
+				if (!renderedFirstLine) {
+					const [firstLine, ...restLines] = require_emit_setext.splitLines(listRegionItemBody(block, context, strippedFirstBlock), "\n");
+					text += [firstLine, ...restLines.map((line) => `${indent}${line}`)].join("\n");
+					renderedFirstLine = true;
+					previousStyleId = lastStyleIdOfRegionItem(block);
+					continue;
+				}
+				const rendered = listRegionItemBody(block, context, void 0).split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
+				const blank = loose || requiresBlankLineBefore(block, previousStyleId, context);
+				text += blank ? `\n\n${rendered}` : `\n${rendered}`;
+				previousStyleId = lastStyleIdOfRegionItem(block);
+			}
+		}
+		parts.push({
+			numId,
+			text
+		});
+		index = next;
+	}
+	let out = "";
+	for (const [partIndex, part] of parts.entries()) {
+		if (partIndex > 0) {
+			const previous = parts[partIndex - 1];
+			const continuesTightly = previous.numId === part.numId && (previous.numId === void 0 || require_shared_list_id.parseListNumId(previous.numId)?.loose !== true);
+			out += continuesTightly ? "\n" : "\n\n";
+		}
+		out += part.text;
+	}
+	return out;
+}
+function isConstructItem(item) {
+	return "descriptor" in item;
+}
+const UNINDENTED_PT = 0;
+function isMaterialisedDivision(item) {
+	return item.descriptor.kind === "division" && item.children.every((child) => {
+		if (isConstructItem(child)) return true;
+		return child.block.kind !== "paragraph" || (child.block.indentLeftPt ?? 0) >= 36;
+	});
+}
+function groupConstructItems(blocks, start) {
+	const items = [];
+	let index = start;
+	for (;;) {
+		const block = blocks[index];
+		if (block === void 0) break;
+		index += 1;
+		if (block.kind === "constructEnd") return {
+			items,
+			next: index
+		};
+		if (block.kind === "constructStart") {
+			const nested = groupConstructItems(blocks, index);
+			items.push({
+				descriptor: block.descriptor,
+				children: nested.items
+			});
+			index = nested.next;
+			continue;
+		}
+		items.push({ block });
+	}
+	return {
+		items,
+		next: index
+	};
+}
+const FOOTNOTE_CONTINUATION_INDENT = 4;
+function renderFootnoteDefinition(name, body) {
+	const marker = `[^${name}]:`;
+	if (body.length === 0) return marker;
+	const indent = " ".repeat(4);
+	const [firstLine, ...restLines] = require_emit_setext.splitLines(body, "\n");
+	return [`${marker} ${firstLine}`, ...restLines.map((line) => line.length === 0 ? line : `${indent}${line}`)].join("\n");
+}
+function renderConstruct(item, context) {
+	const { descriptor } = item;
+	if (descriptor.kind === "anchor" && descriptor.anchorType === "footnote") {
+		const body = renderItems(item.children, context);
+		if (require_inline_footnote.isValidFootnoteLabel(descriptor.name)) return renderFootnoteDefinition(descriptor.name, body);
+		context.sink({
+			code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+			severity: "info",
+			message: `a footnote anchor's own name "${descriptor.name}" cannot be spelled as a "[^label]:" marker (whitespace or "]" would reparse as something else); its own extent still renders in place, but the construct itself is not represented`
+		});
+		return body;
+	}
+	if (isMaterialisedDivision(item)) {
+		context.divisionDepth += 1;
+		const body = renderItems(item.children, context);
+		context.divisionDepth -= 1;
+		return body.split("\n").map((line) => line.length === 0 ? ">" : `> ${line}`).join("\n");
+	}
+	if (descriptor.kind === "link" && descriptor.target.kind === "external") {
+		const onlyChild = item.children.length === 1 && !isConstructItem(item.children[0]) ? item.children[0].block : void 0;
+		if (onlyChild?.kind === "image" && !isDataUri(descriptor.target.uri)) return `![${require_emit_inline.escapeMarkdownText(onlyChild.altText ?? "")}](${require_emit_inline.escapeLinkDestination(descriptor.target.uri)}${descriptor.title === void 0 ? "" : ` "${require_emit_inline.renderLinkTitle(descriptor.title)}"`})`;
+		if (onlyChild?.kind === "image" && isDataUri(descriptor.target.uri) && !context.embedImages) return require_emit_image.emitImage(onlyChild, false);
+	}
+	const body = renderItems(item.children, context);
+	const detail = descriptor.kind === "anchor" ? `${descriptor.kind} (${descriptor.anchorType})` : descriptor.kind;
+	context.sink({
+		code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+		severity: "info",
+		message: `a "${detail}" construct has no markdown syntax; its own extent still renders in place, but the construct itself is not represented`
+	});
+	return body;
+}
+function constructCarriesListItemId(item, itemId) {
+	return item.children.some((child) => {
+		if (isConstructItem(child)) return constructCarriesListItemId(child, itemId);
+		if (child.block.kind !== "paragraph") return false;
+		const list = child.block.list;
+		if (list?.itemId === itemId) return true;
+		return list?.numId !== void 0 && require_shared_list_id.parseListNumId(list.numId)?.ownerItemId === itemId;
+	});
+}
+function isInheritedListMembership(list, context) {
+	return list.itemId !== void 0 && list.itemId === context.enclosingItemId;
+}
+function renderItems(items, context) {
+	const parts = [];
+	let index = 0;
+	for (;;) {
+		const item = items[index];
+		if (item === void 0) break;
+		if (isConstructItem(item)) {
+			const rendered = renderConstruct(item, context);
+			if (rendered.length > 0) parts.push(rendered);
+			index += 1;
+			continue;
+		}
+		if (item.block.kind === "paragraph" && item.block.list !== void 0 && !isInheritedListMembership(item.block.list, context)) {
+			const region = [];
+			let end = index;
+			const openMemberships = [];
+			for (;;) {
+				const candidate = items[end];
+				if (candidate === void 0) break;
+				if (isConstructItem(candidate)) {
+					let matched;
+					for (let i = openMemberships.length - 1; i >= 0; i -= 1) {
+						const membership = openMemberships[i];
+						if (membership.itemId !== void 0 && constructCarriesListItemId(candidate, membership.itemId)) {
+							matched = membership;
+							break;
+						}
+					}
+					if (matched === void 0) break;
+					region.push({
+						kind: "construct",
+						item: candidate,
+						list: matched
+					});
+					end += 1;
+					continue;
+				}
+				if (candidate.block.kind !== "paragraph" || candidate.block.list === void 0 || isInheritedListMembership(candidate.block.list, context)) break;
+				const list = candidate.block.list;
+				while (openMemberships.length > 0 && openMemberships[openMemberships.length - 1].level >= list.level) openMemberships.pop();
+				openMemberships.push(list);
+				region.push({
+					kind: "paragraph",
+					block: candidate.block,
+					list
+				});
+				end += 1;
+			}
+			parts.push(renderListRegion(region, context));
+			index = end;
+			continue;
+		}
+		const rendered = renderTopLevelBlock(item.block, context);
+		if (rendered.length > 0) parts.push(rendered);
+		index += 1;
+	}
+	return parts.join("\n\n");
+}
+//#endregion
+//#region src/emit/emit.ts
+function isDataUri(destination) {
+	return destination.startsWith("data:");
+}
+function canInterruptOpenParagraph(paragraph, context) {
+	const styleId = paragraph.styleId;
+	if (styleId === void 0) return false;
+	if (styleId === "CodeBlock" || styleId === "MathBlock") return true;
+	if (styleId === "HorizontalRule") return context.thematicBreakChar !== "-";
+	const headingLevel = require_shared_style_constants.parseHeadingStyleId(styleId);
+	if (headingLevel !== void 0) return !require_emit_setext.willRenderAsSetext(paragraph, (0, document_schema_js.clampHeadingLevel)(headingLevel), context);
+	return false;
+}
+function quoteDepthOf(paragraph) {
+	if (paragraph.indentLeftPt === void 0 || paragraph.indentLeftPt <= 0) return 0;
+	return Math.max(1, Math.round(paragraph.indentLeftPt / 36));
+}
+function renderParagraphBody(paragraph, context) {
+	if (paragraph.styleId === "HorizontalRule") return context.thematicBreakChar.repeat(3);
+	if (paragraph.styleId === "CodeBlock") {
+		const literal = paragraph.runs.map((run) => run.text).join("");
+		const fence = require_emit_setext.codeFenceFor(literal, context.codeFenceChar);
+		const remainder = paragraph.source?.format === "markdown" ? paragraph.source.xml : void 0;
+		const info = [paragraph.codeLanguage, remainder].filter((part) => part !== void 0 && part.length > 0).join(" ");
+		const opening = info.length > 0 ? `${fence} ${info}` : fence;
+		return literal.length === 0 ? `${opening}\n${fence}` : `${opening}\n${literal}\n${fence}`;
+	}
+	if (paragraph.styleId === "HTMLPreformatted") return paragraph.source?.format === "markdown" ? paragraph.source.xml : paragraph.runs.map((run) => run.text).join("");
+	if (paragraph.styleId === "MathBlock") return `$$\n${paragraph.runs.map((run) => run.text).join("")}\n$$`;
+	const headingLevel = paragraph.styleId === void 0 ? void 0 : require_shared_style_constants.parseHeadingStyleId(paragraph.styleId);
+	if (headingLevel !== void 0) {
+		const level = (0, document_schema_js.clampHeadingLevel)(headingLevel);
+		if (level !== headingLevel) context.sink({
+			code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.HEADING_LEVEL_CLAMPED,
+			severity: "info",
+			message: `heading level ${String(headingLevel)} exceeds ATX's own six-"#" ceiling and is clamped to ${String(level)}`
+		});
+		const text = require_emit_inline.emitRuns(paragraph.runs, context, paragraph.constructs);
+		const embedsLineBreak = require_shared_line_ending.LINE_ENDING_PATTERN.test(text);
+		const unsafeSetextReason = require_emit_setext.unsafeSetextBreakReason(text);
+		const unsafeForSetext = unsafeSetextReason !== void 0;
+		const setextRequested = context.headingStyle === "setext" || embedsLineBreak;
+		if (setextRequested && level <= 2 && !unsafeForSetext) {
+			if (context.headingStyle !== "setext") {
+				const leadingBreakAbsorbed = require_emit_setext.firstContentLineIndex(text) > 0;
+				context.sink({
+					code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.HEADING_STYLE_OVERRIDDEN_FOR_LINE_BREAK,
+					severity: "info",
+					message: leadingBreakAbsorbed ? `the effective WriteMarkdownOptions.headingStyle is 'atx' (its own default, or an explicit caller choice), but this level ${String(level)} heading's own content contains a line break ATX has no way to hold — rendered as setext instead, though the heading's own leading blank line is absorbed as ordinary space ahead of it on read-back rather than reproduced inside it` : `the effective WriteMarkdownOptions.headingStyle is 'atx' (its own default, or an explicit caller choice), but this level ${String(level)} heading's own content contains a line break ATX has no way to hold — rendered as setext instead so the break survives`
+				});
+			}
+			return require_emit_setext.renderSetextHeading(level, text);
+		}
+		if (setextRequested && level <= 2 && unsafeForSetext) {
+			context.sink({
+				code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.HEADING_LINE_BREAK_UNSAFE_FOR_SETEXT,
+				severity: "info",
+				message: require_emit_setext.unsafeSetextDiagnosticMessage(level, unsafeSetextReason, embedsLineBreak)
+			});
+			return require_emit_setext.renderAtxHeading(level, text);
+		}
+		if (embedsLineBreak) context.sink({
+			code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.HEADING_LINE_BREAK_COLLAPSED,
+			severity: "info",
+			message: `a level ${String(level)} heading's own content contains a line break; only setext's own level-1/2 grammar can hold one, so ATX collapses it to a single space`
+		});
+		return require_emit_setext.renderAtxHeading(level, text);
+	}
+	return require_emit_inline.emitRuns(paragraph.runs, context, paragraph.constructs);
+}
+function renderParagraph(paragraph, context) {
+	const body = renderParagraphBody(paragraph, context);
+	const depth = context.divisionDepth > 0 ? 0 : quoteDepthOf(paragraph);
+	if (depth === 0) return body;
+	if (!require_emit_setext.isQuotableStyle(paragraph.styleId)) {
+		context.sink({
+			code: require_diagnostics_diagnostics.MarkdownDiagnosticCodes.PARAGRAPH_INDENT_DROPPED,
+			severity: "info",
+			message: `paragraph carries indentLeftPt (${String(paragraph.indentLeftPt)}pt) with no styleId this package recognises as quotable; the indent has no other markdown representation and is dropped`
+		});
+		return body;
+	}
+	const prefix = "> ".repeat(depth);
+	return body.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function renderTopLevelBlock(block, context) {
+	switch (block.kind) {
+		case "paragraph": return renderParagraph(block, context);
+		case "table": return require_emit_table.emitTable(block, context);
+		case "image": return require_emit_image.emitImage(block, context.embedImages);
+		case "embeddedObject":
+			if (block.objectKind === "formula" && block.document.kind === "formula" && block.document.formula.presentation !== void 0) {
+				const latex = block.document.formula.presentation.latex;
+				return latex.length === 0 ? "$$\n$$" : `$$\n${latex}\n$$`;
+			}
+			return "";
+		case "pageBreak": return "";
+	}
+	return assertNeverRenderableBlock(block);
+}
+function emitBlocks(blocks, context) {
+	const imbalance = (0, document_schema_js.findConstructMarkerImbalance)(blocks);
+	if (imbalance !== void 0) throw new require_diagnostics_diagnostics.MarkdownUnbalancedConstructMarkersError(imbalance.kind, imbalance.index);
+	validateRunConstructExtents(blocks);
+	return renderItems(groupConstructItems(blocks, 0).items, context);
+}
+function validateRunConstructExtents(blocks) {
+	for (const block of blocks) {
+		if (block.kind === "paragraph") {
+			const fault = (0, document_schema_js.findRunConstructFault)(block);
+			if (fault !== void 0) throw new require_diagnostics_diagnostics.MarkdownInvalidRunConstructExtentError(fault.kind, fault.index);
+		}
+		if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) validateRunConstructExtents(cell.blocks);
+	}
+}
+function emitMarkdown(document, options = {}) {
+	if (document.kind !== "wordprocessing") throw new require_diagnostics_diagnostics.MarkdownUnsupportedDocumentKindError(document.kind);
+	const context = {
+		sink: options.sink ?? require_diagnostics_diagnostics.NOOP_MARKDOWN_DIAGNOSTIC_SINK,
+		emphasisMarker: options.emphasisMarker ?? "_",
+		bulletMarker: options.bulletListMarker ?? "-",
+		orderedDelimiter: options.orderedListDelimiter ?? ".",
+		codeFenceChar: options.codeFenceChar ?? "`",
+		thematicBreakChar: options.thematicBreakChar ?? "-",
+		headingStyle: options.headingStyle ?? "atx",
+		embedImages: options.images ?? true,
+		orderedCounters: /* @__PURE__ */ new Map(),
+		resolvedListGlyphs: /* @__PURE__ */ new Map(),
+		reportedFallbackNumIds: /* @__PURE__ */ new Set(),
+		reportedAbsentNumIdFallback: false,
+		divisionDepth: 0,
+		enclosingItemId: void 0
+	};
+	const body = document.sections.map((section) => emitBlocks(section.blocks, context)).join("\n\n");
+	const frontMatter = options.frontMatter === true ? require_emit_front_matter.emitFrontMatter(document.metadata) : void 0;
+	const text = frontMatter === void 0 ? body : `${frontMatter}\n\n${body}`;
+	return (options.lineEnding ?? "lf") === "crlf" ? text.replaceAll("\n", "\r\n") : text;
+}
+function assertNeverRenderableBlock(block) {
+	throw new Error(`markdown-codec: unhandled renderable block ${JSON.stringify(block)}`);
+}
+//#endregion
+Object.defineProperty(exports, "BULLET_GLYPH_CANDIDATES", {
+	enumerable: true,
+	get: function() {
+		return BULLET_GLYPH_CANDIDATES;
+	}
+});
+Object.defineProperty(exports, "FOOTNOTE_CONTINUATION_INDENT", {
+	enumerable: true,
+	get: function() {
+		return FOOTNOTE_CONTINUATION_INDENT;
+	}
+});
+Object.defineProperty(exports, "ORDERED_GLYPH_CANDIDATES", {
+	enumerable: true,
+	get: function() {
+		return ORDERED_GLYPH_CANDIDATES;
+	}
+});
+Object.defineProperty(exports, "UNINDENTED_PT", {
+	enumerable: true,
+	get: function() {
+		return UNINDENTED_PT;
+	}
+});
+Object.defineProperty(exports, "assertNeverRenderableBlock", {
+	enumerable: true,
+	get: function() {
+		return assertNeverRenderableBlock;
+	}
+});
+Object.defineProperty(exports, "canInterruptOpenParagraph", {
+	enumerable: true,
+	get: function() {
+		return canInterruptOpenParagraph;
+	}
+});
+Object.defineProperty(exports, "collectListItem", {
+	enumerable: true,
+	get: function() {
+		return collectListItem;
+	}
+});
+Object.defineProperty(exports, "constructCarriesListItemId", {
+	enumerable: true,
+	get: function() {
+		return constructCarriesListItemId;
+	}
+});
+Object.defineProperty(exports, "consumeSameItemRun", {
+	enumerable: true,
+	get: function() {
+		return consumeSameItemRun;
+	}
+});
+Object.defineProperty(exports, "emitItemCanInterrupt", {
+	enumerable: true,
+	get: function() {
+		return emitItemCanInterrupt;
+	}
+});
+Object.defineProperty(exports, "emitMarkdown", {
+	enumerable: true,
+	get: function() {
+		return emitMarkdown;
+	}
+});
+Object.defineProperty(exports, "firstBlockCheckbox", {
+	enumerable: true,
+	get: function() {
+		return firstBlockCheckbox;
+	}
+});
+Object.defineProperty(exports, "groupConstructItems", {
+	enumerable: true,
+	get: function() {
+		return groupConstructItems;
+	}
+});
+Object.defineProperty(exports, "isConstructItem", {
+	enumerable: true,
+	get: function() {
+		return isConstructItem;
+	}
+});
+Object.defineProperty(exports, "isDataUri", {
+	enumerable: true,
+	get: function() {
+		return isDataUri;
+	}
+});
+Object.defineProperty(exports, "isInheritedListMembership", {
+	enumerable: true,
+	get: function() {
+		return isInheritedListMembership;
+	}
+});
+Object.defineProperty(exports, "isMaterialisedDivision", {
+	enumerable: true,
+	get: function() {
+		return isMaterialisedDivision;
+	}
+});
+Object.defineProperty(exports, "lastStyleIdOf", {
+	enumerable: true,
+	get: function() {
+		return lastStyleIdOf;
+	}
+});
+Object.defineProperty(exports, "lastStyleIdOfRegionItem", {
+	enumerable: true,
+	get: function() {
+		return lastStyleIdOfRegionItem;
+	}
+});
+Object.defineProperty(exports, "listInfoFor", {
+	enumerable: true,
+	get: function() {
+		return listInfoFor;
+	}
+});
+Object.defineProperty(exports, "listRegionItemBody", {
+	enumerable: true,
+	get: function() {
+		return listRegionItemBody;
+	}
+});
+Object.defineProperty(exports, "regionItemCanInterrupt", {
+	enumerable: true,
+	get: function() {
+		return regionItemCanInterrupt;
+	}
+});
+Object.defineProperty(exports, "renderConstruct", {
+	enumerable: true,
+	get: function() {
+		return renderConstruct;
+	}
+});
+Object.defineProperty(exports, "renderFootnoteDefinition", {
+	enumerable: true,
+	get: function() {
+		return renderFootnoteDefinition;
+	}
+});
+Object.defineProperty(exports, "renderItems", {
+	enumerable: true,
+	get: function() {
+		return renderItems;
+	}
+});
+Object.defineProperty(exports, "renderListItemMarker", {
+	enumerable: true,
+	get: function() {
+		return renderListItemMarker;
+	}
+});
+Object.defineProperty(exports, "renderListRegion", {
+	enumerable: true,
+	get: function() {
+		return renderListRegion;
+	}
+});
+Object.defineProperty(exports, "renderParagraphBody", {
+	enumerable: true,
+	get: function() {
+		return renderParagraphBody;
+	}
+});
+Object.defineProperty(exports, "renderTopLevelBlock", {
+	enumerable: true,
+	get: function() {
+		return renderTopLevelBlock;
+	}
+});
+Object.defineProperty(exports, "requiresBlankLineBefore", {
+	enumerable: true,
+	get: function() {
+		return requiresBlankLineBefore;
+	}
+});
+Object.defineProperty(exports, "resolveListGlyph", {
+	enumerable: true,
+	get: function() {
+		return resolveListGlyph;
+	}
+});
+Object.defineProperty(exports, "stripCheckboxRun", {
+	enumerable: true,
+	get: function() {
+		return stripCheckboxRun;
+	}
+});
+Object.defineProperty(exports, "toEmitItem", {
+	enumerable: true,
+	get: function() {
+		return toEmitItem;
+	}
+});