epub-codec 1.1.0 → 1.2.1

package/dist/xhtml/read.js

@@ -1,10 +1,12 @@
 import { EpubDiagnosticCodes } from "../diagnostics.js";
-import { attrValue, elementsWithTag, findChildElement, rootElement, textContent } from "../xml/query.js";
+import { decodeEntities, decodeTextLikeNode } from "../xml/entities.js";
+import { isTextLikeNode } from "../xml/node.js";
+import { attrValue, findChildElement, rootElement } from "../xml/query.js";
 import { parseXml } from "../xml/parse.js";
-import { decodeEntities } from "../xml/entities.js";
 import { POINTS_PER_PIXEL, detectImageFormat, readImageDimensions } from "../image/dimensions.js";
 import { bytesToBase64 } from "../util/base64.js";
 import { buildXml } from "../xml/build.js";
+import { isInertElement, reportInertElementSkip } from "./context.js";
 import { isFootnoteAside, isFootnoteReferenceAnchor } from "./footnote.js";
 import { HORIZONTAL_RULE_STYLE_ID, MONOSPACE_FONT_FAMILY } from "./style-constants.js";
 import { buildInlineRuns } from "./inline.js";
@@ -61,18 +63,32 @@ function decorateParagraph(paragraph, state) {
 	}
 	return decorated;
 }
+function constructsField(inline) {
+	return inline.constructs.length > 0 ? { constructs: inline.constructs } : {};
+}
 function buildIdElementMap(nodes) {
 	const map = /* @__PURE__ */ new Map();
 	const stack = [...nodes];
 	while (stack.length > 0) {
 		const node = stack.pop();
-		if (node?.type !== "element") continue;
+		if (node?.type !== "element" || isInertElement(node.tag)) continue;
 		const id = attrValue(node, "id");
 		if (id !== void 0 && !map.has(id)) map.set(id, node);
 		stack.push(...node.children);
 	}
 	return map;
 }
+function elementsWithTagSkippingInert(nodes, tag) {
+	const out = [];
+	const stack = [...nodes];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node?.type !== "element" || isInertElement(node.tag)) continue;
+		if (node.tag === tag) out.push(node);
+		stack.push(...node.children);
+	}
+	return out;
+}
 function readStyleResidue(html, context) {
 	const head = findChildElement(html.children, "head");
 	if (head === void 0) return;
@@ -99,7 +115,7 @@ function readXhtmlBody(xml, options) {
 	};
 	const idElements = buildIdElementMap(body.children);
 	const footnoteTargetIds = /* @__PURE__ */ new Set();
-	for (const anchor of elementsWithTag(body.children, "a")) {
+	for (const anchor of elementsWithTagSkippingInert(body.children, "a")) {
 		const name = isFootnoteReferenceAnchor(anchor, idElements);
 		if (name !== void 0) footnoteTargetIds.add(name);
 	}
@@ -155,11 +171,11 @@ function readContainerChildren(nodes, state) {
 		if (segment.length === 0) return;
 		const inline = buildInlineRuns(segment, {}, state.context);
 		segment = [];
-		if (inline.runs.every((run) => run.text.trim().length === 0)) return;
+		if (inline.runs.every((run) => run.text.trim().length === 0) && inline.constructs.length === 0) return;
 		const paragraph = {
 			kind: "paragraph",
 			runs: inline.runs,
-			...inline.constructs.length > 0 ? { constructs: inline.constructs } : {}
+			...constructsField(inline)
 		};
 		blocks.push(decorateParagraph(paragraph, state));
 	};
@@ -169,7 +185,7 @@ function readContainerChildren(nodes, state) {
 			blocks.push(...readBlockElement(node, state));
 			continue;
 		}
-		if (node.type === "element" || node.type === "text") segment.push(node);
+		if (node.type === "element" || isTextLikeNode(node)) segment.push(node);
 	}
 	flush();
 	return blocks;
@@ -204,7 +220,7 @@ function readBlockElementInner(element, state) {
 			kind: "paragraph",
 			headingLevel,
 			runs: inline.runs,
-			...inline.constructs.length > 0 ? { constructs: inline.constructs } : {}
+			...constructsField(inline)
 		}, state)];
 	}
 	switch (element.tag) {
@@ -219,12 +235,16 @@ function readBlockElementInner(element, state) {
 		case "ul":
 		case "ol": return readList(element, state);
 		case "dl": return readDefinitionList(element, state);
-		case "table": return [readTable(element, state)];
+		case "table": return readTable(element, state);
 		case "figure": return readContainerChildren(element.children, state);
-		case "figcaption": return [decorateParagraph({
-			kind: "paragraph",
-			runs: buildInlineRuns(element.children, {}, state.context).runs
-		}, state)];
+		case "figcaption": {
+			const inline = buildInlineRuns(element.children, {}, state.context);
+			return [decorateParagraph({
+				kind: "paragraph",
+				runs: inline.runs,
+				...constructsField(inline)
+			}, state)];
+		}
 		case "img": {
 			const block = readImage(element, state);
 			return block === void 0 ? [] : [block];
@@ -236,23 +256,123 @@ function readBlockElementInner(element, state) {
 function readPre(element, state) {
 	const languageSource = findChildElement(element.children, "code") ?? element;
 	const codeLanguage = languageFromClass(attrValue(languageSource, "class"));
-	const text = decodeEntities(textContent(element.children));
+	const inline = containsFootnoteReference(element.children, state.context) ? readPreRuns(element.children, state.context) : {
+		runs: readPreFlatRuns(element.children, state.context),
+		constructs: []
+	};
 	return decorateParagraph({
 		kind: "paragraph",
-		runs: text.length > 0 ? [{
-			text,
-			fontFamily: MONOSPACE_FONT_FAMILY
-		}] : [],
-		...codeLanguage !== void 0 ? { codeLanguage } : {}
+		runs: inline.runs,
+		preformatted: true,
+		...codeLanguage !== void 0 ? { codeLanguage } : {},
+		...constructsField(inline)
 	}, state);
 }
+function readPreFlatRuns(nodes, context) {
+	const text = readPreText(nodes, context);
+	return text.length > 0 ? [{
+		text,
+		fontFamily: MONOSPACE_FONT_FAMILY
+	}] : [];
+}
+function containsFootnoteReference(nodes, context) {
+	for (const node of nodes) {
+		if (node.type !== "element" || isInertElement(node.tag)) continue;
+		if (node.tag === "a" && isFootnoteReferenceAnchor(node, context.idElements) !== void 0) return true;
+		if (containsFootnoteReference(node.children, context)) return true;
+	}
+	return false;
+}
+function readPreRuns(nodes, context) {
+	const runs = [];
+	const constructs = [];
+	let buffer = "";
+	const flush = () => {
+		if (buffer.length === 0) return;
+		runs.push({
+			text: buffer,
+			fontFamily: MONOSPACE_FONT_FAMILY
+		});
+		buffer = "";
+	};
+	for (const node of nodes) {
+		if (isTextLikeNode(node)) {
+			buffer += decodeTextLikeNode(node);
+			continue;
+		}
+		if (node.type !== "element") continue;
+		if (isInertElement(node.tag)) {
+			reportInertElementSkip(node.tag, context);
+			continue;
+		}
+		if (node.tag === "img") {
+			buffer += decodeEntities(readPreImageFallbackText(node, context));
+			continue;
+		}
+		if (node.tag === "br") {
+			buffer += "\n";
+			continue;
+		}
+		const footnoteName = node.tag === "a" ? isFootnoteReferenceAnchor(node, context.idElements) : void 0;
+		if (footnoteName === void 0 && !containsFootnoteReference([node], context)) {
+			buffer += readPreText(node.children, context);
+			continue;
+		}
+		flush();
+		const startRun = runs.length;
+		const nested = readPreRuns(node.children, context);
+		runs.push(...nested.runs);
+		for (const construct of nested.constructs) constructs.push({
+			...construct,
+			startRun: construct.startRun + startRun,
+			endRun: construct.endRun + startRun
+		});
+		if (footnoteName !== void 0) constructs.push({
+			descriptor: {
+				kind: "anchor",
+				anchorType: "footnote",
+				name: footnoteName
+			},
+			startRun,
+			endRun: runs.length
+		});
+	}
+	flush();
+	return {
+		runs,
+		constructs
+	};
+}
+function readPreText(nodes, context) {
+	let out = "";
+	for (const node of nodes) if (isTextLikeNode(node)) out += decodeTextLikeNode(node);
+	else if (node.type === "element" && node.tag === "br") out += "\n";
+	else if (node.type === "element" && node.tag === "img") out += decodeEntities(readPreImageFallbackText(node, context));
+	else if (node.type === "element" && isInertElement(node.tag)) {
+		reportInertElementSkip(node.tag, context);
+		continue;
+	} else if (node.type === "element") out += readPreText(node.children, context);
+	return out;
+}
+function readPreImageFallbackText(element, context) {
+	const src = attrValue(element, "src");
+	const alt = attrValue(element, "alt");
+	const label = src === void 0 ? "<img>" : `<img src="${src}">`;
+	context.sink({
+		code: EpubDiagnosticCodes.IMAGE_PRE_UNSUPPORTED,
+		severity: "warning",
+		message: `${label} inside a <pre>/<code> block cannot become a real image block (this package reads a <pre> as a single text-content paragraph, so there is no block list to insert an image block into); degraded to its alt text`,
+		href: context.sourceHref
+	});
+	return alt ?? "";
+}
 function languageFromClass(className) {
 	if (className === void 0) return;
 	return /(?:^|\s)language-(\S+)/u.exec(className)?.[1];
 }
 function containsHeading(nodes) {
 	for (const node of nodes) {
-		if (node.type !== "element") continue;
+		if (node.type !== "element" || isInertElement(node.tag)) continue;
 		if (headingLevelOf(node.tag) !== void 0) return true;
 		if (containsHeading(node.children)) return true;
 	}
@@ -278,74 +398,237 @@ function readList(element, state) {
 	});
 	const level = state.list === void 0 ? 0 : state.list.level + 1;
 	const blocks = [];
+	let previousItem;
+	let strayNodes = [];
 	for (const child of element.children) {
-		if (child.type !== "element" || child.tag !== "li") continue;
-		const itemState = withListItem(state, {
-			numId,
-			level,
-			itemId: state.minter.mintItemId()
-		});
-		blocks.push(...readContainerChildren(child.children, itemState));
+		if (child.type === "element" && child.tag === "li") {
+			blocks.push(...flushListStrayContent(strayNodes, previousItem, element.tag, state));
+			strayNodes = [];
+			previousItem = {
+				numId,
+				level,
+				itemId: state.minter.mintItemId()
+			};
+			blocks.push(...readContainerChildren(child.children, withListItem(state, previousItem)));
+			continue;
+		}
+		if (child.type === "element" && isInertElement(child.tag)) {
+			reportInertElementSkip(child.tag, state.context);
+			continue;
+		}
+		if (child.type === "element" || isTextLikeNode(child)) strayNodes.push(child);
 	}
+	blocks.push(...flushListStrayContent(strayNodes, previousItem, element.tag, state));
+	return blocks;
+}
+function flushListStrayContent(nodes, previousItem, tag, state) {
+	if (nodes.length === 0) return [];
+	const blocks = readContainerChildren(nodes, previousItem === void 0 ? state : withListItem(state, previousItem));
+	if (blocks.length === 0) return [];
+	state.context.sink({
+		code: EpubDiagnosticCodes.LIST_CONTENT_OUTSIDE_ITEM,
+		severity: "info",
+		message: previousItem === void 0 ? `content sits directly inside a <${tag}> before its first <li> (not valid HTML5); recovered as ordinary content immediately before the list, inheriting whatever list membership its own enclosing context already carries (none, unless this <${tag}> is itself nested inside another list's <li>)` : `content sits directly inside a <${tag}> rather than inside an <li> (not valid HTML5); recovered as a continuation of the preceding <li>'s own content`,
+		href: state.context.sourceHref
+	});
 	return blocks;
 }
 function startAttr(element) {
 	return positiveIntAttr(element, "start");
 }
 function readDefinitionList(element, state) {
+	return readDefinitionListEntries(element.children, state);
+}
+function readDefinitionListEntries(nodes, state) {
 	const blocks = [];
-	for (const child of element.children) {
-		if (child.type !== "element") continue;
-		if (child.tag === "dt") {
+	let strayNodes = [];
+	const flushStray = () => {
+		blocks.push(...flushDefinitionListStrayContent(strayNodes, state));
+		strayNodes = [];
+	};
+	for (const child of nodes) {
+		if (child.type === "element" && child.tag === "dt") {
+			flushStray();
 			const inline = buildInlineRuns(child.children, {}, state.context);
 			blocks.push(decorateParagraph({
 				kind: "paragraph",
-				runs: inline.runs
+				runs: inline.runs,
+				...constructsField(inline)
 			}, state));
-		} else if (child.tag === "dd") {
+			continue;
+		}
+		if (child.type === "element" && child.tag === "dd") {
+			flushStray();
 			const inline = buildInlineRuns(child.children, {}, state.context);
 			blocks.push(decorateParagraph({
 				kind: "paragraph",
 				runs: inline.runs,
+				...constructsField(inline),
 				indentLeftPt: 36 + state.quoteDepth * 36
 			}, state));
+			continue;
+		}
+		if (child.type === "element" && child.tag === "div") {
+			flushStray();
+			blocks.push(...readDefinitionListEntries(child.children, state));
+			continue;
 		}
+		if (child.type === "element" && isInertElement(child.tag)) {
+			reportInertElementSkip(child.tag, state.context);
+			continue;
+		}
+		if (child.type === "element" || isTextLikeNode(child)) strayNodes.push(child);
 	}
+	flushStray();
+	return blocks;
+}
+function flushDefinitionListStrayContent(nodes, state) {
+	if (nodes.length === 0) return [];
+	const blocks = readContainerChildren(nodes, state);
+	if (blocks.length === 0) return [];
+	state.context.sink({
+		code: EpubDiagnosticCodes.DEFINITION_LIST_CONTENT_OUTSIDE_ENTRY,
+		severity: "info",
+		message: "content sits directly inside a <dl> (or one of its <div> wrappers) outside any dt/dd (not valid HTML5); recovered as ordinary content -- a non-conformant wrapper's own dt/dd children, if any, lose their distinct term/definition treatment and degrade to plain concatenated text",
+		href: state.context.sourceHref
+	});
 	return blocks;
 }
 function readTable(element, state) {
+	const captionElements = element.children.filter((c) => c.type === "element" && c.tag === "caption");
 	const rows = [];
 	let columnCount = 0;
+	const strayNodes = [];
 	for (const section of element.children) {
-		if (section.type !== "element") continue;
-		const rowContainers = section.tag === "tr" ? [section] : section.tag === "thead" || section.tag === "tbody" || section.tag === "tfoot" ? section.children.filter((c) => c.type === "element" && c.tag === "tr") : [];
+		if (section.type === "element" && section.tag === "caption") continue;
+		if (section.type !== "element") {
+			if (isTextLikeNode(section)) strayNodes.push(section);
+			continue;
+		}
+		if (section.tag === "colgroup") {
+			collectColgroupStrayContent(section, strayNodes, state.context);
+			continue;
+		}
+		if (isInertElement(section.tag)) {
+			reportInertElementSkip(section.tag, state.context);
+			continue;
+		}
+		const rowContainers = section.tag === "tr" ? [section] : section.tag === "thead" || section.tag === "tbody" || section.tag === "tfoot" ? collectRowGroupRows(section, strayNodes, state.context) : void 0;
+		if (rowContainers === void 0) {
+			strayNodes.push(section);
+			continue;
+		}
 		for (const tr of rowContainers) {
 			const cells = [];
-			for (const cellNode of tr.children) {
-				if (cellNode.type !== "element" || cellNode.tag !== "td" && cellNode.tag !== "th") continue;
-				const cellStyle = cellNode.tag === "th" ? { bold: true } : {};
-				const paragraph = {
-					kind: "paragraph",
-					runs: buildInlineRuns(cellNode.children, cellStyle, state.context).runs
-				};
-				const colSpan = positiveIntAttr(cellNode, "colspan");
-				const rowSpan = positiveIntAttr(cellNode, "rowspan");
-				cells.push({
-					blocks: [paragraph],
-					...colSpan !== void 0 ? { colSpan } : {},
-					...rowSpan !== void 0 ? { rowSpan } : {}
+			let strayCellNodes = [];
+			const flushStrayCell = () => {
+				if (strayCellNodes.length === 0) return;
+				const recovered = readContainerChildren(strayCellNodes, state);
+				strayCellNodes = [];
+				if (recovered.length === 0) return;
+				state.context.sink({
+					code: EpubDiagnosticCodes.TABLE_ROW_CONTENT_OUTSIDE_CELL,
+					severity: "info",
+					message: "content sits directly inside a <tr> rather than inside a <td>/<th> (not valid HTML5); recovered as its own cell in the row's own column sequence",
+					href: state.context.sourceHref
 				});
+				cells.push({ blocks: recovered });
+			};
+			for (const cellNode of tr.children) {
+				if (cellNode.type === "element" && (cellNode.tag === "td" || cellNode.tag === "th")) {
+					flushStrayCell();
+					const cellStyle = cellNode.tag === "th" ? { bold: true } : {};
+					const inline = buildInlineRuns(cellNode.children, cellStyle, state.context);
+					const paragraph = {
+						kind: "paragraph",
+						runs: inline.runs,
+						...constructsField(inline)
+					};
+					const colSpan = positiveIntAttr(cellNode, "colspan");
+					const rowSpan = positiveIntAttr(cellNode, "rowspan");
+					cells.push({
+						blocks: [paragraph],
+						...colSpan !== void 0 ? { colSpan } : {},
+						...rowSpan !== void 0 ? { rowSpan } : {}
+					});
+					continue;
+				}
+				if (cellNode.type === "element" && isInertElement(cellNode.tag)) {
+					reportInertElementSkip(cellNode.tag, state.context);
+					continue;
+				}
+				if (cellNode.type === "element" || isTextLikeNode(cellNode)) strayCellNodes.push(cellNode);
 			}
+			flushStrayCell();
 			columnCount = Math.max(columnCount, cells.length);
 			rows.push({ cells });
 		}
 	}
+	const strayBlocks = strayNodes.length === 0 ? [] : readContainerChildren(strayNodes, state);
+	if (strayBlocks.length > 0) state.context.sink({
+		code: EpubDiagnosticCodes.TABLE_CONTENT_UNRECOGNIZED,
+		severity: "info",
+		message: "content sits directly inside a <table> (or one of its <thead>/<tbody>/<tfoot> row groups) outside any row, caption, or colgroup, or inside a <colgroup> itself (not valid HTML5); recovered as ordinary content immediately before the table",
+		href: state.context.sourceHref
+	});
 	const width = columnCount > 0 ? state.contentWidthPt / columnCount : state.contentWidthPt;
-	return {
+	const table = {
 		kind: "table",
 		rows,
 		columnWidthsPt: new Array(Math.max(columnCount, 1)).fill(width)
 	};
+	const captionBlocks = captionElements.flatMap((captionElement, index) => readTableCaption(captionElement, index > 0, state));
+	return [
+		...strayBlocks,
+		...captionBlocks,
+		table
+	];
+}
+function collectRowGroupRows(section, strayNodes, context) {
+	const trs = [];
+	for (const child of section.children) {
+		if (child.type === "element" && child.tag === "tr") {
+			trs.push(child);
+			continue;
+		}
+		if (child.type === "element" && isInertElement(child.tag)) {
+			reportInertElementSkip(child.tag, context);
+			continue;
+		}
+		if (child.type === "element" || isTextLikeNode(child)) strayNodes.push(child);
+	}
+	return trs;
+}
+function collectColgroupStrayContent(section, strayNodes, context) {
+	for (const child of section.children) {
+		if (child.type === "element" && child.tag === "col") continue;
+		if (child.type === "element" && isInertElement(child.tag)) {
+			reportInertElementSkip(child.tag, context);
+			continue;
+		}
+		if (child.type === "element" || isTextLikeNode(child)) strayNodes.push(child);
+	}
+}
+function readTableCaption(captionElement, isDuplicate, state) {
+	const captionInline = buildInlineRuns(captionElement.children, {}, state.context);
+	if (captionInline.runs.every((run) => run.text.trim().length === 0) && captionInline.constructs.length === 0) return [];
+	if (isDuplicate) state.context.sink({
+		code: EpubDiagnosticCodes.TABLE_DUPLICATE_CAPTION,
+		severity: "info",
+		message: "<table> carries more than one <caption> (HTML5 permits at most one); every caption beyond the first is still read as its own ordinary paragraph immediately before the table, rather than being silently discarded",
+		href: state.context.sourceHref
+	});
+	state.context.sink({
+		code: EpubDiagnosticCodes.TABLE_CAPTION_UNSUPPORTED,
+		severity: "info",
+		message: "<caption> has no document-schema.js table-caption field to carry its own distinct tag; read as an ordinary paragraph immediately before the table",
+		href: state.context.sourceHref
+	});
+	return [decorateParagraph({
+		kind: "paragraph",
+		runs: captionInline.runs,
+		...constructsField(captionInline)
+	}, state)];
 }
 function positiveIntAttr(element, name) {
 	const raw = attrValue(element, name);

package/dist/xhtml/write.cjs

@@ -60,24 +60,31 @@ function writeSectionChildren(children, context) {
 	return out;
 }
 function writeSectionChild(child, context) {
-	if ((0, document_schema_js.isHeadingGroupNode)(child)) return [writeHeading(child), ...writeSectionChildren(child.children, context)];
+	if ((0, document_schema_js.isHeadingGroupNode)(child)) return [writeHeading(child, context), ...writeSectionChildren(child.children, context)];
 	if ((0, document_schema_js.isListGroupNode)(child)) return [writeList([child], context)];
 	if ((0, document_schema_js.isSectionConstructGroupNode)(child)) return writeSectionConstructGroup(child, context);
 	return writeLeafBlock(child, context);
 }
-function writeHeading(group) {
+function writeHeading(group, context) {
 	const level = Math.min(6, Math.max(1, group.node.headingLevel));
-	return element(`h${String(level)}`, {}, writeRunsToNodes(group.node.runs, group.node.constructs));
+	return element(`h${String(level)}`, {}, writeRunsToNodes(group.node.runs, group.node.constructs, context));
 }
 function writeList(items, context) {
 	const numId = items[0]?.node.list.numId;
 	const info = numId === void 0 ? void 0 : require_xhtml_list_id.parseListNumId(numId);
-	return element(info?.type === "ordered" ? "ol" : "ul", info?.type === "ordered" && info.start !== void 0 ? { start: String(info.start) } : {}, items.map((item) => {
-		const paragraph = item.node;
-		const anchorNodes = writeRunsToNodes(paragraph.runs, paragraph.constructs);
-		const nested = writeSectionChildren(item.children, context);
-		return element("li", {}, [...anchorNodes, ...nested]);
-	}));
+	const tag = info?.type === "ordered" ? "ol" : "ul";
+	const attrs = info?.type === "ordered" && info.start !== void 0 ? { start: String(info.start) } : {};
+	const liNodes = [];
+	let index = 0;
+	while (index < items.length) {
+		const itemId = items[index]?.node.list.itemId;
+		let end = index + 1;
+		if (itemId !== void 0) while (end < items.length && items[end]?.node.list.itemId === itemId) end += 1;
+		const liChildren = items.slice(index, end).flatMap((item, position) => [...writeParagraphAsEmbeddedNodes(item.node, context, position > 0), ...writeSectionChildren(item.children, context)]);
+		liNodes.push(element("li", {}, liChildren));
+		index = end;
+	}
+	return element(tag, attrs, liNodes);
 }
 function writeSectionConstructGroup(group, context) {
 	const descriptor = group.node;
@@ -96,7 +103,7 @@ function writeSectionConstructGroup(group, context) {
 }
 function writeLeafBlock(block, context) {
 	switch (block.kind) {
-		case "paragraph": return [writeParagraph(block)];
+		case "paragraph": return [writeParagraph(block, context)];
 		case "table": return [writeTable(block, context)];
 		case "image": return [writeImage(block, context)];
 		case "pageBreak": return [];
@@ -111,38 +118,80 @@ function writeLeafBlock(block, context) {
 	}
 }
 function isPreBlockParagraph(paragraph) {
+	if (paragraph.preformatted === true) return true;
 	if (paragraph.codeLanguage !== void 0) return true;
 	return paragraph.runs.length === 1 && paragraph.runs[0]?.fontFamily === "Courier New" && paragraph.runs[0].text.includes("\n");
 }
-function writeParagraph(paragraph) {
-	if (paragraph.styleId === "HorizontalRule" && paragraph.runs.length === 0) return element("hr");
-	if (isPreBlockParagraph(paragraph)) return element("pre", {}, [element("code", paragraph.codeLanguage === void 0 ? {} : { class: `language-${paragraph.codeLanguage}` }, [text(paragraph.runs.map((run) => run.text).join(""))])]);
-	return element("p", {}, writeRunsToNodes(paragraph.runs, paragraph.constructs));
+function isHorizontalRuleParagraph(paragraph) {
+	return paragraph.styleId === "HorizontalRule" && paragraph.runs.length === 0;
+}
+function writePreElement(paragraph, context) {
+	return element("pre", {}, [element("code", paragraph.codeLanguage === void 0 ? {} : { class: `language-${paragraph.codeLanguage}` }, writePreRunsToNodes(paragraph.runs, paragraph.constructs, context))]);
+}
+function writeParagraph(paragraph, context) {
+	if (isHorizontalRuleParagraph(paragraph)) return element("hr");
+	if (isPreBlockParagraph(paragraph)) return writePreElement(paragraph, context);
+	return element("p", {}, writeRunsToNodes(paragraph.runs, paragraph.constructs, context));
+}
+function writeParagraphAsEmbeddedNodes(paragraph, context, wrapOrdinaryInParagraph) {
+	if (isHorizontalRuleParagraph(paragraph)) return [element("hr")];
+	if (isPreBlockParagraph(paragraph)) return [writePreElement(paragraph, context)];
+	const runNodes = writeRunsToNodes(paragraph.runs, paragraph.constructs, context);
+	return wrapOrdinaryInParagraph ? [element("p", {}, runNodes)] : runNodes;
 }
 function isFootnoteExtent(construct) {
 	return construct.descriptor.kind === "anchor" && construct.descriptor.anchorType === "footnote";
 }
-function writeRunsToNodes(runs, constructs) {
+function describeUnrepresentedFootnoteExtent(extent) {
+	if (extent.endRun === extent.startRun) return `a footnote reference ('${extent.descriptor.name}') marking the boundary before run ${extent.startRun} is never reached by the write walk -- either because it sits inside another footnote reference's own winning run range, or because its own run range falls outside this paragraph's actual runs; a point anchor wraps no run text of its own, so nothing besides this reference's own <a> link is missing from the output`;
+	return `a footnote reference ('${extent.descriptor.name}') is never reached by the write walk and cannot be represented as its own <a> element -- either because it overlaps another footnote reference's own winning run range, or because its own run range falls outside this paragraph's actual runs; wherever an overlap is the cause, the run text underneath it is not lost, since it is still written, wrapped by whichever extent's range actually claims it, or written unwrapped past it, but this reference's own anchor link is not emitted regardless of cause`;
+}
+function writeRunRangeNodes(runs, constructs, renderRun, renderExtentRange, context) {
 	const footnoteExtents = (constructs ?? []).filter(isFootnoteExtent);
+	const emittedExtents = /* @__PURE__ */ new Set();
 	const out = [];
 	let index = 0;
-	while (index < runs.length) {
-		const extent = footnoteExtents.find((e) => e.startRun === index);
-		if (extent !== void 0) {
-			const inner = runs.slice(extent.startRun, extent.endRun).flatMap((run) => writeRunNodes(run));
+	while (index <= runs.length) {
+		const extentsHere = footnoteExtents.filter((e) => e.startRun === index);
+		for (const point of extentsHere.filter((e) => e.endRun === e.startRun)) {
+			emittedExtents.add(point);
 			out.push(element("a", {
 				"epub:type": "noteref",
-				href: `#${extent.descriptor.name}`
-			}, inner));
-			index = Math.max(extent.endRun, index + 1);
+				href: `#${point.descriptor.name}`
+			}, renderExtentRange([])));
+		}
+		const [primaryRange] = index < runs.length ? extentsHere.filter((e) => e.endRun > e.startRun) : [];
+		if (primaryRange !== void 0) {
+			emittedExtents.add(primaryRange);
+			const rangeRuns = runs.slice(primaryRange.startRun, primaryRange.endRun);
+			out.push(element("a", {
+				"epub:type": "noteref",
+				href: `#${primaryRange.descriptor.name}`
+			}, renderExtentRange(rangeRuns)));
+			index = primaryRange.endRun;
 			continue;
 		}
 		const run = runs[index];
-		if (run !== void 0) out.push(...writeRunNodes(run));
+		if (run !== void 0) out.push(...renderRun(run));
 		index += 1;
 	}
+	for (const extent of footnoteExtents) {
+		if (emittedExtents.has(extent)) continue;
+		context.sink({
+			code: require_diagnostics.EpubDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+			severity: "info",
+			message: describeUnrepresentedFootnoteExtent(extent),
+			href: context.sourceHref
+		});
+	}
 	return out;
 }
+function writeRunsToNodes(runs, constructs, context) {
+	return writeRunRangeNodes(runs, constructs, writeRunNodes, (rangeRuns) => rangeRuns.flatMap((run) => writeRunNodes(run)), context);
+}
+function writePreRunsToNodes(runs, constructs, context) {
+	return writeRunRangeNodes(runs, constructs, (run) => run.text.length > 0 ? [text(run.text)] : [], (rangeRuns) => [text(rangeRuns.map((run) => run.text).join(""))], context);
+}
 function writeRunNodes(run) {
 	const segments = run.text.split("\n");
 	let nodes = [];

package/dist/xhtml/write.d.cts

@@ -1,4 +1,4 @@
-import { i as EpubDiagnosticSink } from "../diagnostics-tvGwPH46.cjs";
+import { i as EpubDiagnosticSink } from "../diagnostics-C0CRdoda.cjs";
 import { XmlElement } from "../xml/node.cjs";
 import { ContentBlock, ContentImageBlock } from "document-schema.js";
 //#region src/xhtml/write.d.ts

package/dist/xhtml/write.d.ts

@@ -1,4 +1,4 @@
-import { i as EpubDiagnosticSink } from "../diagnostics-tvGwPH46.js";
+import { i as EpubDiagnosticSink } from "../diagnostics-C0CRdoda.js";
 import { XmlElement } from "../xml/node.js";
 import { ContentBlock, ContentImageBlock } from "document-schema.js";
 //#region src/xhtml/write.d.ts