epub-codec 1.1.0 → 1.2.1

package/dist/xhtml/write.js

@@ -59,24 +59,31 @@ function writeSectionChildren(children, context) {
 	return out;
 }
 function writeSectionChild(child, context) {
-	if (isHeadingGroupNode(child)) return [writeHeading(child), ...writeSectionChildren(child.children, context)];
+	if (isHeadingGroupNode(child)) return [writeHeading(child, context), ...writeSectionChildren(child.children, context)];
 	if (isListGroupNode(child)) return [writeList([child], context)];
 	if (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 : 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;
@@ -95,7 +102,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 [];
@@ -110,38 +117,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: 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/xml/entities.cjs

@@ -1,20 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let entities = require("entities");
 //#region src/xml/entities.ts
 function decodeEntities(value) {
-	return value.replace(/&(?:amp|lt|gt|quot|apos);/g, (entity) => {
-		switch (entity) {
-			case "&": return "&";
-			case "&lt;": return "<";
-			case "&gt;": return ">";
-			case "&quot;": return "\"";
-			case "&apos;": return "'";
-			default: return entity;
-		}
-	});
+	return (0, entities.decode)(value, entities.EntityLevel.HTML);
+}
+function decodeTextLikeNode(node) {
+	return node.type === "cdata" ? node.value : decodeEntities(node.value);
 }
 function encodeEntities(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 //#endregion
 exports.decodeEntities = decodeEntities;
+exports.decodeTextLikeNode = decodeTextLikeNode;
 exports.encodeEntities = encodeEntities;

package/dist/xml/entities.d.cts

@@ -1,5 +1,7 @@
+import { XmlCdata, XmlText } from "./node.cjs";
 //#region src/xml/entities.d.ts
 declare function decodeEntities(value: string): string;
+declare function decodeTextLikeNode(node: XmlText | XmlCdata): string;
 declare function encodeEntities(value: string): string;
 //#endregion
-export { decodeEntities, encodeEntities };
+export { decodeEntities, decodeTextLikeNode, encodeEntities };

package/dist/xml/entities.d.ts

@@ -1,5 +1,7 @@
+import { XmlCdata, XmlText } from "./node.js";
 //#region src/xml/entities.d.ts
 declare function decodeEntities(value: string): string;
+declare function decodeTextLikeNode(node: XmlText | XmlCdata): string;
 declare function encodeEntities(value: string): string;
 //#endregion
-export { decodeEntities, encodeEntities };
+export { decodeEntities, decodeTextLikeNode, encodeEntities };

package/dist/xml/entities.js

@@ -1,18 +1,13 @@
+import { EntityLevel, decode } from "entities";
 //#region src/xml/entities.ts
 function decodeEntities(value) {
-	return value.replace(/&(?:amp|lt|gt|quot|apos);/g, (entity) => {
-		switch (entity) {
-			case "&": return "&";
-			case "&lt;": return "<";
-			case "&gt;": return ">";
-			case "&quot;": return "\"";
-			case "&apos;": return "'";
-			default: return entity;
-		}
-	});
+	return decode(value, EntityLevel.HTML);
+}
+function decodeTextLikeNode(node) {
+	return node.type === "cdata" ? node.value : decodeEntities(node.value);
 }
 function encodeEntities(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 //#endregion
-export { decodeEntities, encodeEntities };
+export { decodeEntities, decodeTextLikeNode, encodeEntities };

package/dist/xml/node.cjs

@@ -26,6 +26,9 @@ const XmlPiSchema = zod.z.object({
 	target: zod.z.string(),
 	content: zod.z.string()
 });
+function isTextLikeNode(node) {
+	return node.type === "text" || node.type === "cdata";
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -64,4 +67,5 @@ exports.XmlElementSchema = XmlElementSchema;
 exports.XmlNodeSchema = XmlNodeSchema;
 exports.XmlPiSchema = XmlPiSchema;
 exports.XmlTextSchema = XmlTextSchema;
+exports.isTextLikeNode = isTextLikeNode;
 exports.isXmlNode = isXmlNode;

package/dist/xml/node.d.cts

@@ -41,6 +41,7 @@ interface XmlElement {
   children: XmlNode[];
 }
 type XmlNode = XmlText | XmlCdata | XmlComment | XmlDeclaration | XmlPi | XmlElement;
+declare function isTextLikeNode(node: XmlNode): node is XmlText | XmlCdata;
 declare function isXmlNode(value: unknown): value is XmlNode;
 declare const XmlElementSchema: z.ZodObject<{
   type: z.ZodLiteral<"element">;
@@ -80,4 +81,4 @@ declare const XmlNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
 }, z.core.$strip>], "type">;
 //#endregion
-export { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isXmlNode };
+export { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isTextLikeNode, isXmlNode };

package/dist/xml/node.d.ts

@@ -41,6 +41,7 @@ interface XmlElement {
   children: XmlNode[];
 }
 type XmlNode = XmlText | XmlCdata | XmlComment | XmlDeclaration | XmlPi | XmlElement;
+declare function isTextLikeNode(node: XmlNode): node is XmlText | XmlCdata;
 declare function isXmlNode(value: unknown): value is XmlNode;
 declare const XmlElementSchema: z.ZodObject<{
   type: z.ZodLiteral<"element">;
@@ -80,4 +81,4 @@ declare const XmlNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   children: z.ZodArray<z.ZodCustom<XmlNode, XmlNode>>;
 }, z.core.$strip>], "type">;
 //#endregion
-export { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isXmlNode };
+export { Attribute, AttributeSchema, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElementSchema, XmlNode, XmlNodeSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, isTextLikeNode, isXmlNode };

package/dist/xml/node.js

@@ -25,6 +25,9 @@ const XmlPiSchema = z.object({
 	target: z.string(),
 	content: z.string()
 });
+function isTextLikeNode(node) {
+	return node.type === "text" || node.type === "cdata";
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -55,4 +58,4 @@ const XmlNodeSchema = z.discriminatedUnion("type", [
 	XmlElementSchema
 ]);
 //#endregion
-export { AttributeSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPiSchema, XmlTextSchema, isXmlNode };
+export { AttributeSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPiSchema, XmlTextSchema, isTextLikeNode, isXmlNode };

package/dist/xml/query.cjs

@@ -1,4 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xml_entities = require("./entities.cjs");
+const require_xml_node = require("./node.cjs");
 //#region src/xml/query.ts
 function rootElement(nodes) {
 	for (const node of nodes) if (node.type === "element") return node;
@@ -34,9 +36,16 @@ function textContent(nodes) {
 	else if (node.type === "element") out += textContent(node.children);
 	return out;
 }
+function decodedTextContent(nodes) {
+	let out = "";
+	for (const node of nodes) if (require_xml_node.isTextLikeNode(node)) out += require_xml_entities.decodeTextLikeNode(node);
+	else if (node.type === "element") out += decodedTextContent(node.children);
+	return out;
+}
 //#endregion
 exports.attrValue = attrValue;
 exports.childrenWithTag = childrenWithTag;
+exports.decodedTextContent = decodedTextContent;
 exports.elementsWithTag = elementsWithTag;
 exports.findChildElement = findChildElement;
 exports.findElement = findElement;

package/dist/xml/query.d.cts

@@ -7,5 +7,6 @@ declare function elementsWithTag(nodes: readonly XmlNode[], tag: string): XmlEle
 declare function findElement(nodes: readonly XmlNode[], predicate: (element: XmlElement) => boolean): XmlElement | undefined;
 declare function attrValue(element: XmlElement, name: string): string | undefined;
 declare function textContent(nodes: readonly XmlNode[]): string;
+declare function decodedTextContent(nodes: readonly XmlNode[]): string;
 //#endregion
-export { attrValue, childrenWithTag, elementsWithTag, findChildElement, findElement, rootElement, textContent };
+export { attrValue, childrenWithTag, decodedTextContent, elementsWithTag, findChildElement, findElement, rootElement, textContent };

package/dist/xml/query.d.ts

@@ -7,5 +7,6 @@ declare function elementsWithTag(nodes: readonly XmlNode[], tag: string): XmlEle
 declare function findElement(nodes: readonly XmlNode[], predicate: (element: XmlElement) => boolean): XmlElement | undefined;
 declare function attrValue(element: XmlElement, name: string): string | undefined;
 declare function textContent(nodes: readonly XmlNode[]): string;
+declare function decodedTextContent(nodes: readonly XmlNode[]): string;
 //#endregion
-export { attrValue, childrenWithTag, elementsWithTag, findChildElement, findElement, rootElement, textContent };
+export { attrValue, childrenWithTag, decodedTextContent, elementsWithTag, findChildElement, findElement, rootElement, textContent };

package/dist/xml/query.js

@@ -1,3 +1,5 @@
+import { decodeTextLikeNode } from "./entities.js";
+import { isTextLikeNode } from "./node.js";
 //#region src/xml/query.ts
 function rootElement(nodes) {
 	for (const node of nodes) if (node.type === "element") return node;
@@ -33,5 +35,11 @@ function textContent(nodes) {
 	else if (node.type === "element") out += textContent(node.children);
 	return out;
 }
+function decodedTextContent(nodes) {
+	let out = "";
+	for (const node of nodes) if (isTextLikeNode(node)) out += decodeTextLikeNode(node);
+	else if (node.type === "element") out += decodedTextContent(node.children);
+	return out;
+}
 //#endregion
-export { attrValue, childrenWithTag, elementsWithTag, findChildElement, findElement, rootElement, textContent };
+export { attrValue, childrenWithTag, decodedTextContent, elementsWithTag, findChildElement, findElement, rootElement, textContent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "epub-codec",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "EPUB 2/3 reading and deterministic EPUB 3 writing against the shared document-schema.js content pivot.",
   "type": "module",
   "repository": {
@@ -78,7 +78,8 @@
   "license": "MIT",
   "packageManager": "pnpm@11.6.0",
   "dependencies": {
-    "document-schema.js": "^6.1.0",
+    "document-schema.js": "^6.2.0",
+    "entities": "^8.0.0",
     "fast-xml-parser": "^5.10.1",
     "fflate": "^0.8.3",
     "zod": "^4.4.3"