epub-codec 0.0.0 → 1.0.0

package/dist/opf/parse.js

@@ -0,0 +1,46 @@
+import { EpubInvalidOpfError, NOOP_EPUB_DIAGNOSTIC_SINK } from "../diagnostics.js";
+import { attrValue, childrenWithTag, findChildElement, rootElement } from "../xml/query.js";
+import { parseXml } from "../xml/parse.js";
+import { readOpfMetadata } from "./metadata.js";
+//#region src/opf/parse.ts
+function parseOpf(opfXml, sink = NOOP_EPUB_DIAGNOSTIC_SINK) {
+	const nodes = parseXml(opfXml);
+	const root = rootElement(nodes);
+	if (root?.tag !== "package") throw new EpubInvalidOpfError("the OPF document has no <package> root element");
+	const metadataElement = findChildElement(root.children, "metadata");
+	const metadata = metadataElement === void 0 ? {} : readOpfMetadata(metadataElement, sink);
+	const manifestElement = findChildElement(root.children, "manifest");
+	if (manifestElement === void 0) throw new EpubInvalidOpfError("the OPF document has no <manifest> element");
+	const manifest = childrenWithTag(manifestElement, "item").map(parseManifestItem).filter((item) => item !== void 0);
+	const spineElement = findChildElement(root.children, "spine");
+	if (spineElement === void 0) throw new EpubInvalidOpfError("the OPF document has no <spine> element");
+	return {
+		metadata,
+		manifest,
+		spine: childrenWithTag(spineElement, "itemref").map(parseSpineItemRef).filter((item) => item !== void 0),
+		ncxId: attrValue(spineElement, "toc")
+	};
+}
+function parseManifestItem(element) {
+	const id = attrValue(element, "id");
+	const href = attrValue(element, "href");
+	const mediaType = attrValue(element, "media-type");
+	if (id === void 0 || href === void 0 || mediaType === void 0) return;
+	const properties = attrValue(element, "properties");
+	return {
+		id,
+		href,
+		mediaType,
+		properties: properties === void 0 ? [] : properties.split(/\s+/u).filter((p) => p.length > 0)
+	};
+}
+function parseSpineItemRef(element) {
+	const idref = attrValue(element, "idref");
+	if (idref === void 0) return;
+	return {
+		idref,
+		linear: attrValue(element, "linear") !== "no"
+	};
+}
+//#endregion
+export { parseOpf };

package/dist/opf/types.d.cts

@@ -0,0 +1,20 @@
+import { LayoutMetadata } from "document-schema.js";
+//#region src/opf/types.d.ts
+interface OpfManifestItem {
+  readonly id: string;
+  readonly href: string;
+  readonly mediaType: string;
+  readonly properties: readonly string[];
+}
+interface OpfSpineItemRef {
+  readonly idref: string;
+  readonly linear: boolean;
+}
+interface OpfPackage {
+  readonly metadata: LayoutMetadata;
+  readonly manifest: readonly OpfManifestItem[];
+  readonly spine: readonly OpfSpineItemRef[];
+  readonly ncxId: string | undefined;
+}
+//#endregion
+export { OpfManifestItem, OpfPackage, OpfSpineItemRef };

package/dist/opf/types.d.ts

@@ -0,0 +1,20 @@
+import { LayoutMetadata } from "document-schema.js";
+//#region src/opf/types.d.ts
+interface OpfManifestItem {
+  readonly id: string;
+  readonly href: string;
+  readonly mediaType: string;
+  readonly properties: readonly string[];
+}
+interface OpfSpineItemRef {
+  readonly idref: string;
+  readonly linear: boolean;
+}
+interface OpfPackage {
+  readonly metadata: LayoutMetadata;
+  readonly manifest: readonly OpfManifestItem[];
+  readonly spine: readonly OpfSpineItemRef[];
+  readonly ncxId: string | undefined;
+}
+//#endregion
+export { OpfManifestItem, OpfPackage, OpfSpineItemRef };

package/dist/opf/write.cjs

@@ -0,0 +1,55 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xml_entities = require("../xml/entities.cjs");
+const require_xml_build = require("../xml/build.cjs");
+//#region src/opf/write.ts
+function element(tag, attrs = {}, children = []) {
+	return {
+		type: "element",
+		tag,
+		attributes: Object.entries(attrs).map(([name, value]) => ({
+			name,
+			value
+		})),
+		children
+	};
+}
+function text(value) {
+	return {
+		type: "text",
+		value: require_xml_entities.encodeEntities(value)
+	};
+}
+function dcElement(tag, value) {
+	return element(tag, {}, [text(value)]);
+}
+function writeOpf(input) {
+	const metadataChildren = [element("dc:identifier", { id: "pub-id" }, [text(input.identifier)])];
+	if (input.metadata.title !== void 0) metadataChildren.push(dcElement("dc:title", input.metadata.title));
+	if (input.metadata.author !== void 0) metadataChildren.push(dcElement("dc:creator", input.metadata.author));
+	for (const keyword of input.metadata.keywords ?? []) metadataChildren.push(dcElement("dc:subject", keyword));
+	metadataChildren.push(dcElement("dc:language", input.metadata.language ?? "en"));
+	if (input.metadata.createdIso !== void 0) metadataChildren.push(dcElement("dc:date", input.metadata.createdIso));
+	if (input.metadata.modifiedIso !== void 0) metadataChildren.push(element("meta", { property: "dcterms:modified" }, [text(input.metadata.modifiedIso)]));
+	const manifestChildren = input.manifestItems.map((item) => {
+		const attrs = {
+			id: item.id,
+			href: item.href,
+			"media-type": item.mediaType
+		};
+		if (item.properties.length > 0) attrs.properties = item.properties.join(" ");
+		return element("item", attrs);
+	});
+	const spineChildren = input.spineIdrefs.map((idref) => element("itemref", { idref }));
+	const packageElement = element("package", {
+		xmlns: "http://www.idpf.org/2007/opf",
+		version: "3.0",
+		"unique-identifier": "pub-id"
+	}, [
+		element("metadata", { "xmlns:dc": "http://purl.org/dc/elements/1.1/" }, metadataChildren),
+		element("manifest", {}, manifestChildren),
+		element("spine", {}, spineChildren)
+	]);
+	return `<?xml version="1.0" encoding="UTF-8"?>\n${require_xml_build.buildXml([packageElement])}`;
+}
+//#endregion
+exports.writeOpf = writeOpf;

package/dist/opf/write.d.cts

@@ -0,0 +1,12 @@
+import { OpfManifestItem } from "./types.cjs";
+import { LayoutMetadata } from "document-schema.js";
+//#region src/opf/write.d.ts
+interface WriteOpfInput {
+  readonly metadata: LayoutMetadata;
+  readonly manifestItems: readonly OpfManifestItem[];
+  readonly spineIdrefs: readonly string[];
+  readonly identifier: string;
+}
+declare function writeOpf(input: WriteOpfInput): string;
+//#endregion
+export { WriteOpfInput, writeOpf };

package/dist/opf/write.d.ts

@@ -0,0 +1,12 @@
+import { OpfManifestItem } from "./types.js";
+import { LayoutMetadata } from "document-schema.js";
+//#region src/opf/write.d.ts
+interface WriteOpfInput {
+  readonly metadata: LayoutMetadata;
+  readonly manifestItems: readonly OpfManifestItem[];
+  readonly spineIdrefs: readonly string[];
+  readonly identifier: string;
+}
+declare function writeOpf(input: WriteOpfInput): string;
+//#endregion
+export { WriteOpfInput, writeOpf };

package/dist/opf/write.js

@@ -0,0 +1,54 @@
+import { encodeEntities } from "../xml/entities.js";
+import { buildXml } from "../xml/build.js";
+//#region src/opf/write.ts
+function element(tag, attrs = {}, children = []) {
+	return {
+		type: "element",
+		tag,
+		attributes: Object.entries(attrs).map(([name, value]) => ({
+			name,
+			value
+		})),
+		children
+	};
+}
+function text(value) {
+	return {
+		type: "text",
+		value: encodeEntities(value)
+	};
+}
+function dcElement(tag, value) {
+	return element(tag, {}, [text(value)]);
+}
+function writeOpf(input) {
+	const metadataChildren = [element("dc:identifier", { id: "pub-id" }, [text(input.identifier)])];
+	if (input.metadata.title !== void 0) metadataChildren.push(dcElement("dc:title", input.metadata.title));
+	if (input.metadata.author !== void 0) metadataChildren.push(dcElement("dc:creator", input.metadata.author));
+	for (const keyword of input.metadata.keywords ?? []) metadataChildren.push(dcElement("dc:subject", keyword));
+	metadataChildren.push(dcElement("dc:language", input.metadata.language ?? "en"));
+	if (input.metadata.createdIso !== void 0) metadataChildren.push(dcElement("dc:date", input.metadata.createdIso));
+	if (input.metadata.modifiedIso !== void 0) metadataChildren.push(element("meta", { property: "dcterms:modified" }, [text(input.metadata.modifiedIso)]));
+	const manifestChildren = input.manifestItems.map((item) => {
+		const attrs = {
+			id: item.id,
+			href: item.href,
+			"media-type": item.mediaType
+		};
+		if (item.properties.length > 0) attrs.properties = item.properties.join(" ");
+		return element("item", attrs);
+	});
+	const spineChildren = input.spineIdrefs.map((idref) => element("itemref", { idref }));
+	const packageElement = element("package", {
+		xmlns: "http://www.idpf.org/2007/opf",
+		version: "3.0",
+		"unique-identifier": "pub-id"
+	}, [
+		element("metadata", { "xmlns:dc": "http://purl.org/dc/elements/1.1/" }, metadataChildren),
+		element("manifest", {}, manifestChildren),
+		element("spine", {}, spineChildren)
+	]);
+	return `<?xml version="1.0" encoding="UTF-8"?>\n${buildXml([packageElement])}`;
+}
+//#endregion
+export { writeOpf };

package/dist/path.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/path.ts
+function dirname(path) {
+	const slash = path.lastIndexOf("/");
+	return slash === -1 ? "" : path.slice(0, slash);
+}
+function resolvePackagePath(baseDir, relative) {
+	if (relative.startsWith("/") || /^[a-z][a-z0-9+.-]*:/iu.test(relative)) return relative;
+	const segments = [...baseDir.length > 0 ? baseDir.split("/") : []];
+	for (const part of relative.split("/")) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") {
+			segments.pop();
+			continue;
+		}
+		segments.push(part);
+	}
+	return segments.join("/");
+}
+//#endregion
+exports.dirname = dirname;
+exports.resolvePackagePath = resolvePackagePath;

package/dist/path.d.cts

@@ -0,0 +1,5 @@
+//#region src/path.d.ts
+declare function dirname(path: string): string;
+declare function resolvePackagePath(baseDir: string, relative: string): string;
+//#endregion
+export { dirname, resolvePackagePath };

package/dist/path.d.ts

@@ -0,0 +1,5 @@
+//#region src/path.d.ts
+declare function dirname(path: string): string;
+declare function resolvePackagePath(baseDir: string, relative: string): string;
+//#endregion
+export { dirname, resolvePackagePath };

package/dist/path.js

@@ -0,0 +1,20 @@
+//#region src/path.ts
+function dirname(path) {
+	const slash = path.lastIndexOf("/");
+	return slash === -1 ? "" : path.slice(0, slash);
+}
+function resolvePackagePath(baseDir, relative) {
+	if (relative.startsWith("/") || /^[a-z][a-z0-9+.-]*:/iu.test(relative)) return relative;
+	const segments = [...baseDir.length > 0 ? baseDir.split("/") : []];
+	for (const part of relative.split("/")) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") {
+			segments.pop();
+			continue;
+		}
+		segments.push(part);
+	}
+	return segments.join("/");
+}
+//#endregion
+export { dirname, resolvePackagePath };

package/dist/read.cjs

@@ -0,0 +1,166 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_diagnostics = require("./diagnostics.cjs");
+const require_ocf_container = require("./ocf/container.cjs");
+require("./format.cjs");
+const require_nav_nav3 = require("./nav/nav3.cjs");
+const require_nav_ncx = require("./nav/ncx.cjs");
+const require_nav_reconcile = require("./nav/reconcile.cjs");
+const require_opf_parse = require("./opf/parse.cjs");
+const require_xhtml_read = require("./xhtml/read.cjs");
+const require_path = require("./path.cjs");
+const require_zip = require("./zip.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/read.ts
+const A4_MARGINS = {
+	topPt: 72,
+	rightPt: 72,
+	bottomPt: 72,
+	leftPt: 72
+};
+const CONTENT_WIDTH_PT = document_schema_js.PAGE_SIZE_A4.widthPt - A4_MARGINS.leftPt - A4_MARGINS.rightPt;
+function decodeText(bytes) {
+	return new TextDecoder("utf-8").decode(bytes);
+}
+function readEpubInternal(bytes, sink) {
+	const entries = require_zip.unzipPackage(bytes);
+	const mimetypeBytes = entries.mimetype;
+	if (mimetypeBytes === void 0 || decodeText(mimetypeBytes) !== "application/epub+zip") throw new require_diagnostics.EpubInvalidMimetypeError();
+	const containerBytes = entries["META-INF/container.xml"];
+	if (containerBytes === void 0) throw new require_diagnostics.EpubInvalidContainerError("the zip carries no META-INF/container.xml entry");
+	const opfPath = require_ocf_container.resolveOpfPath(decodeText(containerBytes));
+	const opfBytes = entries[opfPath];
+	if (opfBytes === void 0) throw new require_diagnostics.EpubInvalidOpfError(`META-INF/container.xml names an OPF rootfile ("${opfPath}") the zip does not contain`);
+	const opfDir = require_path.dirname(opfPath);
+	const opf = require_opf_parse.parseOpf(decodeText(opfBytes), sink);
+	const manifestById = new Map(opf.manifest.map((item) => [item.id, item]));
+	const sections = [];
+	const spineFullPaths = [];
+	for (const itemref of opf.spine) {
+		const manifestItem = manifestById.get(itemref.idref);
+		if (manifestItem === void 0) {
+			sink({
+				code: require_diagnostics.EpubDiagnosticCodes.SPINE_ITEMREF_UNRESOLVED,
+				severity: "warning",
+				message: `spine itemref "${itemref.idref}" names no manifest item; skipped`
+			});
+			continue;
+		}
+		const fullPath = require_path.resolvePackagePath(opfDir, manifestItem.href);
+		spineFullPaths.push(fullPath);
+		const xhtmlBytes = entries[fullPath];
+		if (xhtmlBytes === void 0) {
+			sink({
+				code: require_diagnostics.EpubDiagnosticCodes.MANIFEST_ITEM_MISSING,
+				severity: "warning",
+				message: `manifest item "${manifestItem.id}" names a part ("${fullPath}") the zip does not contain; skipped`,
+				href: fullPath
+			});
+			continue;
+		}
+		const sectionDir = require_path.dirname(fullPath);
+		const { blocks, source } = require_xhtml_read.readXhtmlBody(decodeText(xhtmlBytes), {
+			resolveImage: (src) => entries[require_path.resolvePackagePath(sectionDir, src)],
+			sink,
+			sourceHref: fullPath,
+			contentWidthPt: CONTENT_WIDTH_PT
+		});
+		sections.push({
+			pageSize: document_schema_js.PAGE_SIZE_A4,
+			margins: A4_MARGINS,
+			blocks,
+			...source !== void 0 ? { source } : {}
+		});
+	}
+	if (sections.length === 0) throw new require_diagnostics.EpubEmptySpineError();
+	sink({
+		code: require_diagnostics.EpubDiagnosticCodes.INVENTED_PAGE_GEOMETRY,
+		severity: "info",
+		message: "EPUB has no page concept of its own; every section was given A4 + 1in default page geometry"
+	});
+	const navResidue = reconcileNavigation(opf, entries, opfDir, spineFullPaths, sink);
+	return {
+		document: {
+			kind: "wordprocessing",
+			metadata: opf.metadata,
+			sections
+		},
+		navResidue
+	};
+}
+function reconcileNavigation(opf, entries, opfDir, spineFullPaths, sink) {
+	const navItem = opf.manifest.find((item) => item.properties.includes("nav"));
+	if (navItem !== void 0) {
+		const navPath = require_path.resolvePackagePath(opfDir, navItem.href);
+		const navBytes = entries[navPath];
+		if (navBytes !== void 0) {
+			const navXml = decodeText(navBytes);
+			const navHrefs = require_nav_nav3.readNav3TocHrefs(navXml);
+			if (navHrefs === void 0) sink({
+				code: require_diagnostics.EpubDiagnosticCodes.NAV_DOCUMENT_MISSING,
+				severity: "warning",
+				message: `the nav document ("${navPath}") carries no <nav epub:type="toc">`,
+				href: navPath
+			});
+			else {
+				const resolvedNavHrefs = navHrefs.map((href) => require_path.resolvePackagePath(require_path.dirname(navPath), href));
+				if (!require_nav_reconcile.navMatchesSpine(resolvedNavHrefs, spineFullPaths)) {
+					sink({
+						code: require_diagnostics.EpubDiagnosticCodes.NAV_SPINE_ORDER_MISMATCH,
+						severity: "warning",
+						message: "the EPUB 3 navigation document's own toc order disagrees with the spine; the spine's reading order wins and the nav document is quarantined as residue",
+						href: navPath
+					});
+					return {
+						format: "epub",
+						xml: navXml
+					};
+				}
+			}
+		}
+	}
+	if (opf.ncxId !== void 0) {
+		const ncxItem = opf.manifest.find((item) => item.id === opf.ncxId);
+		const ncxPath = ncxItem === void 0 ? void 0 : require_path.resolvePackagePath(opfDir, ncxItem.href);
+		const ncxBytes = ncxPath === void 0 ? void 0 : entries[ncxPath];
+		if (ncxBytes === void 0) {
+			sink({
+				code: require_diagnostics.EpubDiagnosticCodes.NCX_MISSING,
+				severity: "warning",
+				message: `the spine names an NCX ("${opf.ncxId}") the manifest does not resolve to a real part`
+			});
+			return;
+		}
+		const ncxXml = decodeText(ncxBytes);
+		const ncxHrefs = require_nav_ncx.readNcxHrefs(ncxXml);
+		if (ncxHrefs !== void 0) {
+			const resolvedNcxHrefs = ncxHrefs.map((href) => require_path.resolvePackagePath(opfDir, href));
+			if (!require_nav_reconcile.navMatchesSpine(resolvedNcxHrefs, spineFullPaths)) {
+				sink({
+					code: require_diagnostics.EpubDiagnosticCodes.NAV_SPINE_ORDER_MISMATCH,
+					severity: "warning",
+					message: "the EPUB 2 NCX's own navMap order disagrees with the spine; the spine's reading order wins and the NCX is quarantined as residue",
+					href: ncxPath
+				});
+				return {
+					format: "epub",
+					xml: ncxXml
+				};
+			}
+		}
+	}
+}
+function readEpubContent(bytes, options = {}) {
+	const { document } = readEpubInternal(bytes, options.sink ?? require_diagnostics.NOOP_EPUB_DIAGNOSTIC_SINK);
+	return document;
+}
+function readEpub(bytes, options = {}) {
+	const { document, navResidue } = readEpubInternal(bytes, options.sink ?? require_diagnostics.NOOP_EPUB_DIAGNOSTIC_SINK);
+	const tree = (0, document_schema_js.assembleTree)(document);
+	return navResidue === void 0 ? tree : {
+		...tree,
+		source: { nav: navResidue }
+	};
+}
+//#endregion
+exports.readEpub = readEpub;
+exports.readEpubContent = readEpubContent;

package/dist/read.d.cts

@@ -0,0 +1,10 @@
+import { i as EpubDiagnosticSink } from "./diagnostics-Ee4kG7mw.cjs";
+import { ContentDocument, DocumentTree } from "document-schema.js";
+//#region src/read.d.ts
+interface ReadEpubOptions {
+  readonly sink?: EpubDiagnosticSink;
+}
+declare function readEpubContent(bytes: Uint8Array<ArrayBuffer>, options?: ReadEpubOptions): ContentDocument;
+declare function readEpub(bytes: Uint8Array<ArrayBuffer>, options?: ReadEpubOptions): DocumentTree;
+//#endregion
+export { ReadEpubOptions, readEpub, readEpubContent };

package/dist/read.d.ts

@@ -0,0 +1,10 @@
+import { i as EpubDiagnosticSink } from "./diagnostics-Ee4kG7mw.js";
+import { ContentDocument, DocumentTree } from "document-schema.js";
+//#region src/read.d.ts
+interface ReadEpubOptions {
+  readonly sink?: EpubDiagnosticSink;
+}
+declare function readEpubContent(bytes: Uint8Array<ArrayBuffer>, options?: ReadEpubOptions): ContentDocument;
+declare function readEpub(bytes: Uint8Array<ArrayBuffer>, options?: ReadEpubOptions): DocumentTree;
+//#endregion
+export { ReadEpubOptions, readEpub, readEpubContent };

package/dist/read.js

@@ -0,0 +1,164 @@
+import { EpubDiagnosticCodes, EpubEmptySpineError, EpubInvalidContainerError, EpubInvalidMimetypeError, EpubInvalidOpfError, NOOP_EPUB_DIAGNOSTIC_SINK } from "./diagnostics.js";
+import { resolveOpfPath } from "./ocf/container.js";
+import "./format.js";
+import { readNav3TocHrefs } from "./nav/nav3.js";
+import { readNcxHrefs } from "./nav/ncx.js";
+import { navMatchesSpine } from "./nav/reconcile.js";
+import { parseOpf } from "./opf/parse.js";
+import { readXhtmlBody } from "./xhtml/read.js";
+import { dirname, resolvePackagePath } from "./path.js";
+import { unzipPackage } from "./zip.js";
+import { PAGE_SIZE_A4, assembleTree } from "document-schema.js";
+//#region src/read.ts
+const A4_MARGINS = {
+	topPt: 72,
+	rightPt: 72,
+	bottomPt: 72,
+	leftPt: 72
+};
+const CONTENT_WIDTH_PT = PAGE_SIZE_A4.widthPt - A4_MARGINS.leftPt - A4_MARGINS.rightPt;
+function decodeText(bytes) {
+	return new TextDecoder("utf-8").decode(bytes);
+}
+function readEpubInternal(bytes, sink) {
+	const entries = unzipPackage(bytes);
+	const mimetypeBytes = entries.mimetype;
+	if (mimetypeBytes === void 0 || decodeText(mimetypeBytes) !== "application/epub+zip") throw new EpubInvalidMimetypeError();
+	const containerBytes = entries["META-INF/container.xml"];
+	if (containerBytes === void 0) throw new EpubInvalidContainerError("the zip carries no META-INF/container.xml entry");
+	const opfPath = resolveOpfPath(decodeText(containerBytes));
+	const opfBytes = entries[opfPath];
+	if (opfBytes === void 0) throw new EpubInvalidOpfError(`META-INF/container.xml names an OPF rootfile ("${opfPath}") the zip does not contain`);
+	const opfDir = dirname(opfPath);
+	const opf = parseOpf(decodeText(opfBytes), sink);
+	const manifestById = new Map(opf.manifest.map((item) => [item.id, item]));
+	const sections = [];
+	const spineFullPaths = [];
+	for (const itemref of opf.spine) {
+		const manifestItem = manifestById.get(itemref.idref);
+		if (manifestItem === void 0) {
+			sink({
+				code: EpubDiagnosticCodes.SPINE_ITEMREF_UNRESOLVED,
+				severity: "warning",
+				message: `spine itemref "${itemref.idref}" names no manifest item; skipped`
+			});
+			continue;
+		}
+		const fullPath = resolvePackagePath(opfDir, manifestItem.href);
+		spineFullPaths.push(fullPath);
+		const xhtmlBytes = entries[fullPath];
+		if (xhtmlBytes === void 0) {
+			sink({
+				code: EpubDiagnosticCodes.MANIFEST_ITEM_MISSING,
+				severity: "warning",
+				message: `manifest item "${manifestItem.id}" names a part ("${fullPath}") the zip does not contain; skipped`,
+				href: fullPath
+			});
+			continue;
+		}
+		const sectionDir = dirname(fullPath);
+		const { blocks, source } = readXhtmlBody(decodeText(xhtmlBytes), {
+			resolveImage: (src) => entries[resolvePackagePath(sectionDir, src)],
+			sink,
+			sourceHref: fullPath,
+			contentWidthPt: CONTENT_WIDTH_PT
+		});
+		sections.push({
+			pageSize: PAGE_SIZE_A4,
+			margins: A4_MARGINS,
+			blocks,
+			...source !== void 0 ? { source } : {}
+		});
+	}
+	if (sections.length === 0) throw new EpubEmptySpineError();
+	sink({
+		code: EpubDiagnosticCodes.INVENTED_PAGE_GEOMETRY,
+		severity: "info",
+		message: "EPUB has no page concept of its own; every section was given A4 + 1in default page geometry"
+	});
+	const navResidue = reconcileNavigation(opf, entries, opfDir, spineFullPaths, sink);
+	return {
+		document: {
+			kind: "wordprocessing",
+			metadata: opf.metadata,
+			sections
+		},
+		navResidue
+	};
+}
+function reconcileNavigation(opf, entries, opfDir, spineFullPaths, sink) {
+	const navItem = opf.manifest.find((item) => item.properties.includes("nav"));
+	if (navItem !== void 0) {
+		const navPath = resolvePackagePath(opfDir, navItem.href);
+		const navBytes = entries[navPath];
+		if (navBytes !== void 0) {
+			const navXml = decodeText(navBytes);
+			const navHrefs = readNav3TocHrefs(navXml);
+			if (navHrefs === void 0) sink({
+				code: EpubDiagnosticCodes.NAV_DOCUMENT_MISSING,
+				severity: "warning",
+				message: `the nav document ("${navPath}") carries no <nav epub:type="toc">`,
+				href: navPath
+			});
+			else {
+				const resolvedNavHrefs = navHrefs.map((href) => resolvePackagePath(dirname(navPath), href));
+				if (!navMatchesSpine(resolvedNavHrefs, spineFullPaths)) {
+					sink({
+						code: EpubDiagnosticCodes.NAV_SPINE_ORDER_MISMATCH,
+						severity: "warning",
+						message: "the EPUB 3 navigation document's own toc order disagrees with the spine; the spine's reading order wins and the nav document is quarantined as residue",
+						href: navPath
+					});
+					return {
+						format: "epub",
+						xml: navXml
+					};
+				}
+			}
+		}
+	}
+	if (opf.ncxId !== void 0) {
+		const ncxItem = opf.manifest.find((item) => item.id === opf.ncxId);
+		const ncxPath = ncxItem === void 0 ? void 0 : resolvePackagePath(opfDir, ncxItem.href);
+		const ncxBytes = ncxPath === void 0 ? void 0 : entries[ncxPath];
+		if (ncxBytes === void 0) {
+			sink({
+				code: EpubDiagnosticCodes.NCX_MISSING,
+				severity: "warning",
+				message: `the spine names an NCX ("${opf.ncxId}") the manifest does not resolve to a real part`
+			});
+			return;
+		}
+		const ncxXml = decodeText(ncxBytes);
+		const ncxHrefs = readNcxHrefs(ncxXml);
+		if (ncxHrefs !== void 0) {
+			const resolvedNcxHrefs = ncxHrefs.map((href) => resolvePackagePath(opfDir, href));
+			if (!navMatchesSpine(resolvedNcxHrefs, spineFullPaths)) {
+				sink({
+					code: EpubDiagnosticCodes.NAV_SPINE_ORDER_MISMATCH,
+					severity: "warning",
+					message: "the EPUB 2 NCX's own navMap order disagrees with the spine; the spine's reading order wins and the NCX is quarantined as residue",
+					href: ncxPath
+				});
+				return {
+					format: "epub",
+					xml: ncxXml
+				};
+			}
+		}
+	}
+}
+function readEpubContent(bytes, options = {}) {
+	const { document } = readEpubInternal(bytes, options.sink ?? NOOP_EPUB_DIAGNOSTIC_SINK);
+	return document;
+}
+function readEpub(bytes, options = {}) {
+	const { document, navResidue } = readEpubInternal(bytes, options.sink ?? NOOP_EPUB_DIAGNOSTIC_SINK);
+	const tree = assembleTree(document);
+	return navResidue === void 0 ? tree : {
+		...tree,
+		source: { nav: navResidue }
+	};
+}
+//#endregion
+export { readEpub, readEpubContent };