epub-codec 0.0.0 → 1.0.0

package/dist/xhtml/inline.d.ts

@@ -0,0 +1,11 @@
+import { XmlNode } from "../xml/node.js";
+import { InlineStyle, XhtmlReadContext } from "./context.js";
+import { ContentRun, RunConstructExtent } from "document-schema.js";
+//#region src/xhtml/inline.d.ts
+interface InlineResult {
+  readonly runs: ContentRun[];
+  readonly constructs: RunConstructExtent[];
+}
+declare function buildInlineRuns(nodes: readonly XmlNode[], style: InlineStyle, context: XhtmlReadContext): InlineResult;
+//#endregion
+export { InlineResult, buildInlineRuns };

package/dist/xhtml/inline.js

@@ -0,0 +1,127 @@
+import { EpubDiagnosticCodes } from "../diagnostics.js";
+import { attrValue } from "../xml/query.js";
+import { decodeEntities } from "../xml/entities.js";
+import { isFootnoteReferenceAnchor, sameDocumentFragment } from "./footnote.js";
+import { MONOSPACE_FONT_FAMILY } from "./style-constants.js";
+//#region src/xhtml/inline.ts
+function normalizeWhitespace(text) {
+	return text.replace(/[ \t\r\n]+/gu, " ");
+}
+function mergeStyle(outer, inner) {
+	return {
+		...outer,
+		...inner
+	};
+}
+function styledRun(text, style, hyperlink) {
+	const run = { text };
+	if (style.bold === true) run.bold = true;
+	if (style.italic === true) run.italic = true;
+	if (style.underline === true) run.underline = true;
+	if (style.strike === true) run.strike = true;
+	if (style.fontFamily !== void 0) run.fontFamily = style.fontFamily;
+	if (hyperlink !== void 0) run.hyperlink = hyperlink;
+	return run;
+}
+function buildInlineRuns(nodes, style, context) {
+	const runs = [];
+	const constructs = [];
+	for (const node of nodes) {
+		if (node.type === "text") {
+			const text = normalizeWhitespace(decodeEntities(node.value));
+			if (text.length > 0) runs.push(styledRun(text, style));
+			continue;
+		}
+		if (node.type !== "element") continue;
+		appendElement(node, style, context, runs, constructs);
+	}
+	return {
+		runs,
+		constructs
+	};
+}
+function appendElement(element, style, context, runs, constructs) {
+	switch (element.tag) {
+		case "strong":
+		case "b":
+			appendNested(element, mergeStyle(style, { bold: true }), context, runs, constructs);
+			return;
+		case "em":
+		case "i":
+			appendNested(element, mergeStyle(style, { italic: true }), context, runs, constructs);
+			return;
+		case "u":
+			appendNested(element, mergeStyle(style, { underline: true }), context, runs, constructs);
+			return;
+		case "s":
+		case "strike":
+		case "del":
+			appendNested(element, mergeStyle(style, { strike: true }), context, runs, constructs);
+			return;
+		case "code":
+		case "kbd":
+		case "samp":
+			appendNested(element, mergeStyle(style, { fontFamily: MONOSPACE_FONT_FAMILY }), context, runs, constructs);
+			return;
+		case "sub":
+		case "sup":
+			context.sink({
+				code: EpubDiagnosticCodes.ELEMENT_UNMAPPED,
+				severity: "info",
+				message: `<${element.tag}> has no document-schema.js run-level field to carry its vertical position; the text is kept, the styling is not`,
+				href: context.sourceHref
+			});
+			appendNested(element, style, context, runs, constructs);
+			return;
+		case "br":
+			runs.push(styledRun("\n", style));
+			return;
+		case "a":
+			appendAnchor(element, style, context, runs, constructs);
+			return;
+		default: appendNested(element, style, context, runs, constructs);
+	}
+}
+function appendNested(element, style, context, runs, constructs) {
+	const nested = buildInlineRuns(element.children, style, context);
+	runs.push(...nested.runs);
+	constructs.push(...nested.constructs);
+}
+function appendAnchor(element, style, context, runs, constructs) {
+	const footnoteName = isFootnoteReferenceAnchor(element, context.idElements);
+	if (footnoteName !== void 0) {
+		const startRun = runs.length;
+		const nested = buildInlineRuns(element.children, style, context);
+		runs.push(...nested.runs);
+		constructs.push(...nested.constructs);
+		constructs.push({
+			descriptor: {
+				kind: "anchor",
+				anchorType: "footnote",
+				name: footnoteName
+			},
+			startRun,
+			endRun: runs.length
+		});
+		return;
+	}
+	const href = attrValue(element, "href");
+	if (href === void 0 || href.length === 0) {
+		appendNested(element, style, context, runs, constructs);
+		return;
+	}
+	const nested = buildInlineRuns(element.children, style, context);
+	for (const run of nested.runs) runs.push({
+		...run,
+		hyperlink: href
+	});
+	constructs.push(...nested.constructs);
+	if (sameDocumentFragment(href) === void 0 && !/^[a-z][a-z0-9+.-]*:/iu.test(href)) context.sink({
+		code: EpubDiagnosticCodes.LINK_TARGET_EXTERNAL_ONLY,
+		severity: "info",
+		message: `href "${href}" carries no URI scheme and is not a same-document fragment; it is stored verbatim on ContentRun.hyperlink without resolution against the package's own manifest`,
+		href: context.sourceHref
+	});
+}
+//#endregion
+export { buildInlineRuns };

package/dist/xhtml/list-id.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/xhtml/list-id.ts
+const NUMID_PATTERN = /^epub(\d+):(bullet|ordered)(?:@(\d+))?$/u;
+function mintListNumId(nextId, options) {
+	const suffix = options.type === "ordered" && options.start !== void 0 && options.start !== 1 ? `ordered@${String(options.start)}` : options.type;
+	return `epub${String(nextId)}:${suffix}`;
+}
+function parseListNumId(numId) {
+	const match = NUMID_PATTERN.exec(numId);
+	if (match === null) return;
+	const type = match[2];
+	if (type !== "bullet" && type !== "ordered") return;
+	const startText = match[3];
+	if (type === "ordered" && startText !== void 0) return {
+		type,
+		start: Number.parseInt(startText, 10)
+	};
+	return { type };
+}
+//#endregion
+exports.mintListNumId = mintListNumId;
+exports.parseListNumId = parseListNumId;

package/dist/xhtml/list-id.d.cts

@@ -0,0 +1,13 @@
+//#region src/xhtml/list-id.d.ts
+interface ListNumIdInfo {
+  readonly type: "bullet" | "ordered";
+  readonly start?: number;
+}
+interface MintListNumIdOptions {
+  readonly type: "bullet" | "ordered";
+  readonly start?: number;
+}
+declare function mintListNumId(nextId: number, options: MintListNumIdOptions): string;
+declare function parseListNumId(numId: string): ListNumIdInfo | undefined;
+//#endregion
+export { ListNumIdInfo, MintListNumIdOptions, mintListNumId, parseListNumId };

package/dist/xhtml/list-id.d.ts

@@ -0,0 +1,13 @@
+//#region src/xhtml/list-id.d.ts
+interface ListNumIdInfo {
+  readonly type: "bullet" | "ordered";
+  readonly start?: number;
+}
+interface MintListNumIdOptions {
+  readonly type: "bullet" | "ordered";
+  readonly start?: number;
+}
+declare function mintListNumId(nextId: number, options: MintListNumIdOptions): string;
+declare function parseListNumId(numId: string): ListNumIdInfo | undefined;
+//#endregion
+export { ListNumIdInfo, MintListNumIdOptions, mintListNumId, parseListNumId };

package/dist/xhtml/list-id.js

@@ -0,0 +1,20 @@
+//#region src/xhtml/list-id.ts
+const NUMID_PATTERN = /^epub(\d+):(bullet|ordered)(?:@(\d+))?$/u;
+function mintListNumId(nextId, options) {
+	const suffix = options.type === "ordered" && options.start !== void 0 && options.start !== 1 ? `ordered@${String(options.start)}` : options.type;
+	return `epub${String(nextId)}:${suffix}`;
+}
+function parseListNumId(numId) {
+	const match = NUMID_PATTERN.exec(numId);
+	if (match === null) return;
+	const type = match[2];
+	if (type !== "bullet" && type !== "ordered") return;
+	const startText = match[3];
+	if (type === "ordered" && startText !== void 0) return {
+		type,
+		start: Number.parseInt(startText, 10)
+	};
+	return { type };
+}
+//#endregion
+export { mintListNumId, parseListNumId };

package/dist/xhtml/read.cjs

@@ -0,0 +1,423 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_diagnostics = require("../diagnostics.cjs");
+const require_xml_query = require("../xml/query.cjs");
+const require_xml_parse = require("../xml/parse.cjs");
+const require_xml_entities = require("../xml/entities.cjs");
+const require_image_dimensions = require("../image/dimensions.cjs");
+const require_util_base64 = require("../util/base64.cjs");
+const require_xml_build = require("../xml/build.cjs");
+const require_xhtml_footnote = require("./footnote.cjs");
+const require_xhtml_style_constants = require("./style-constants.cjs");
+const require_xhtml_inline = require("./inline.cjs");
+const require_xhtml_list_id = require("./list-id.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/xhtml/read.ts
+function createIdMinter() {
+	let nextList = 0;
+	let nextItem = 0;
+	return {
+		mintNumId: (options) => {
+			nextList += 1;
+			return require_xhtml_list_id.mintListNumId(nextList, options);
+		},
+		mintItemId: () => {
+			nextItem += 1;
+			return `item${String(nextItem)}`;
+		}
+	};
+}
+function withQuote(state) {
+	return {
+		...state,
+		quoteDepth: state.quoteDepth + 1
+	};
+}
+function withListItem(state, listItem) {
+	return {
+		...state,
+		listItem,
+		list: {
+			numId: listItem.numId,
+			level: listItem.level
+		}
+	};
+}
+function decorateParagraph(paragraph, state) {
+	let decorated = paragraph;
+	if (state.quoteDepth > 0) decorated = {
+		...decorated,
+		indentLeftPt: state.quoteDepth * 36,
+		styleId: decorated.styleId ?? "Quote"
+	};
+	if (state.listItem !== void 0) {
+		const membership = {
+			numId: state.listItem.numId,
+			level: state.listItem.level,
+			itemId: state.listItem.itemId
+		};
+		decorated = {
+			...decorated,
+			list: membership
+		};
+	}
+	return decorated;
+}
+function buildIdElementMap(nodes) {
+	const map = /* @__PURE__ */ new Map();
+	const stack = [...nodes];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node?.type !== "element") continue;
+		const id = require_xml_query.attrValue(node, "id");
+		if (id !== void 0 && !map.has(id)) map.set(id, node);
+		stack.push(...node.children);
+	}
+	return map;
+}
+function readStyleResidue(html, context) {
+	const head = require_xml_query.findChildElement(html.children, "head");
+	if (head === void 0) return;
+	const styleElements = head.children.filter((node) => node.type === "element" && (node.tag === "style" || node.tag === "link" && require_xml_query.attrValue(node, "rel") === "stylesheet"));
+	if (styleElements.length === 0) return;
+	context.sink({
+		code: require_diagnostics.EpubDiagnosticCodes.STYLE_RESIDUE,
+		severity: "info",
+		message: "the document's own <head> style declarations (CSS) are quarantined as residue rather than interpreted; the schema is content, not styling",
+		href: context.sourceHref
+	});
+	return {
+		format: "epub",
+		xml: require_xml_build.buildXml(styleElements)
+	};
+}
+function readXhtmlBody(xml, options) {
+	const nodes = require_xml_parse.parseXml(xml);
+	const html = require_xml_query.rootElement(nodes);
+	const body = html === void 0 ? void 0 : require_xml_query.findChildElement(html.children, "body");
+	if (body === void 0 || html === void 0) return {
+		blocks: [],
+		source: void 0
+	};
+	const idElements = buildIdElementMap(body.children);
+	const footnoteTargetIds = /* @__PURE__ */ new Set();
+	for (const anchor of require_xml_query.elementsWithTag(body.children, "a")) {
+		const name = require_xhtml_footnote.isFootnoteReferenceAnchor(anchor, idElements);
+		if (name !== void 0) footnoteTargetIds.add(name);
+	}
+	const context = {
+		resolveImage: options.resolveImage,
+		sink: options.sink,
+		sourceHref: options.sourceHref,
+		idElements,
+		footnoteTargetIds,
+		quoteDepth: 0
+	};
+	const state = {
+		context,
+		minter: createIdMinter(),
+		quoteDepth: 0,
+		listItem: void 0,
+		list: void 0,
+		contentWidthPt: options.contentWidthPt
+	};
+	return {
+		blocks: readContainerChildren(body.children, state),
+		source: readStyleResidue(html, context)
+	};
+}
+const BLOCK_LEVEL_TAGS = /* @__PURE__ */ new Set([
+	"p",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"ul",
+	"ol",
+	"dl",
+	"table",
+	"blockquote",
+	"pre",
+	"hr",
+	"figure",
+	"figcaption",
+	"div",
+	"section",
+	"article",
+	"aside",
+	"nav",
+	"img"
+]);
+function readContainerChildren(nodes, state) {
+	const blocks = [];
+	let segment = [];
+	const flush = () => {
+		if (segment.length === 0) return;
+		const inline = require_xhtml_inline.buildInlineRuns(segment, {}, state.context);
+		segment = [];
+		if (inline.runs.every((run) => run.text.trim().length === 0)) return;
+		const paragraph = {
+			kind: "paragraph",
+			runs: inline.runs,
+			...inline.constructs.length > 0 ? { constructs: inline.constructs } : {}
+		};
+		blocks.push(decorateParagraph(paragraph, state));
+	};
+	for (const node of nodes) {
+		if (node.type === "element" && BLOCK_LEVEL_TAGS.has(node.tag)) {
+			flush();
+			blocks.push(...readBlockElement(node, state));
+			continue;
+		}
+		if (node.type === "element" || node.type === "text") segment.push(node);
+	}
+	flush();
+	return blocks;
+}
+function headingLevelOf(tag) {
+	const match = /^h([1-6])$/u.exec(tag);
+	return match?.[1] === void 0 ? void 0 : (0, document_schema_js.clampHeadingLevel)(Number(match[1]));
+}
+function readBlockElement(element, state) {
+	const id = require_xml_query.attrValue(element, "id");
+	const isFootnoteTarget = id !== void 0 && state.context.footnoteTargetIds.has(id) && !require_xhtml_footnote.isFootnoteAside(element);
+	const blocks = readBlockElementInner(element, state);
+	if (!isFootnoteTarget) return blocks;
+	return [
+		{
+			kind: "constructStart",
+			descriptor: {
+				kind: "anchor",
+				anchorType: "footnote",
+				name: id
+			}
+		},
+		...blocks,
+		{ kind: "constructEnd" }
+	];
+}
+function readBlockElementInner(element, state) {
+	const headingLevel = headingLevelOf(element.tag);
+	if (headingLevel !== void 0) {
+		const inline = require_xhtml_inline.buildInlineRuns(element.children, {}, state.context);
+		return [decorateParagraph({
+			kind: "paragraph",
+			headingLevel,
+			runs: inline.runs,
+			...inline.constructs.length > 0 ? { constructs: inline.constructs } : {}
+		}, state)];
+	}
+	switch (element.tag) {
+		case "p": return readContainerChildren(element.children, state);
+		case "hr": return [decorateParagraph({
+			kind: "paragraph",
+			runs: [],
+			styleId: require_xhtml_style_constants.HORIZONTAL_RULE_STYLE_ID
+		}, state)];
+		case "pre": return [readPre(element, state)];
+		case "blockquote": return readBlockquote(element, state);
+		case "ul":
+		case "ol": return readList(element, state);
+		case "dl": return readDefinitionList(element, state);
+		case "table": return [readTable(element, state)];
+		case "figure": return readContainerChildren(element.children, state);
+		case "figcaption": return [decorateParagraph({
+			kind: "paragraph",
+			runs: require_xhtml_inline.buildInlineRuns(element.children, {}, state.context).runs
+		}, state)];
+		case "img": {
+			const block = readImage(element, state);
+			return block === void 0 ? [] : [block];
+		}
+		case "aside": return readAside(element, state);
+		default: return readContainerChildren(element.children, state);
+	}
+}
+function readPre(element, state) {
+	const languageSource = require_xml_query.findChildElement(element.children, "code") ?? element;
+	const codeLanguage = languageFromClass(require_xml_query.attrValue(languageSource, "class"));
+	const text = require_xml_entities.decodeEntities(require_xml_query.textContent(element.children));
+	return decorateParagraph({
+		kind: "paragraph",
+		runs: text.length > 0 ? [{
+			text,
+			fontFamily: require_xhtml_style_constants.MONOSPACE_FONT_FAMILY
+		}] : [],
+		...codeLanguage !== void 0 ? { codeLanguage } : {}
+	}, state);
+}
+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 (headingLevelOf(node.tag) !== void 0) return true;
+		if (containsHeading(node.children)) return true;
+	}
+	return false;
+}
+function readBlockquote(element, state) {
+	const nestedState = withQuote(state);
+	const blocks = readContainerChildren(element.children, nestedState);
+	if (containsHeading(element.children)) return blocks;
+	return [
+		{
+			kind: "constructStart",
+			descriptor: { kind: "division" }
+		},
+		...blocks,
+		{ kind: "constructEnd" }
+	];
+}
+function readList(element, state) {
+	const numId = state.list?.numId ?? state.minter.mintNumId({
+		type: element.tag === "ol" ? "ordered" : "bullet",
+		start: startAttr(element)
+	});
+	const level = state.list === void 0 ? 0 : state.list.level + 1;
+	const blocks = [];
+	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));
+	}
+	return blocks;
+}
+function startAttr(element) {
+	return positiveIntAttr(element, "start");
+}
+function readDefinitionList(element, state) {
+	const blocks = [];
+	for (const child of element.children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "dt") {
+			const inline = require_xhtml_inline.buildInlineRuns(child.children, {}, state.context);
+			blocks.push(decorateParagraph({
+				kind: "paragraph",
+				runs: inline.runs
+			}, state));
+		} else if (child.tag === "dd") {
+			const inline = require_xhtml_inline.buildInlineRuns(child.children, {}, state.context);
+			blocks.push(decorateParagraph({
+				kind: "paragraph",
+				runs: inline.runs,
+				indentLeftPt: 36 + state.quoteDepth * 36
+			}, state));
+		}
+	}
+	return blocks;
+}
+function readTable(element, state) {
+	const rows = [];
+	let columnCount = 0;
+	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") : [];
+		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: require_xhtml_inline.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 } : {}
+				});
+			}
+			columnCount = Math.max(columnCount, cells.length);
+			rows.push({ cells });
+		}
+	}
+	const width = columnCount > 0 ? state.contentWidthPt / columnCount : state.contentWidthPt;
+	return {
+		kind: "table",
+		rows,
+		columnWidthsPt: new Array(Math.max(columnCount, 1)).fill(width)
+	};
+}
+function positiveIntAttr(element, name) {
+	const raw = require_xml_query.attrValue(element, name);
+	if (raw === void 0) return;
+	const value = Number.parseInt(raw, 10);
+	return Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function readImage(element, state) {
+	const src = require_xml_query.attrValue(element, "src");
+	const alt = require_xml_query.attrValue(element, "alt");
+	if (src === void 0) return;
+	const bytes = state.context.resolveImage(src);
+	if (bytes === void 0) {
+		state.context.sink({
+			code: require_diagnostics.EpubDiagnosticCodes.IMAGE_UNRESOLVED,
+			severity: "warning",
+			message: `<img src="${src}"> names no resolvable manifest part; degraded to its alt text`,
+			href: state.context.sourceHref
+		});
+		return alt === void 0 || alt.length === 0 ? void 0 : decorateParagraph({
+			kind: "paragraph",
+			runs: [{ text: require_xml_entities.decodeEntities(alt) }]
+		}, state);
+	}
+	const format = require_image_dimensions.detectImageFormat(bytes);
+	const dimensions = require_image_dimensions.readImageDimensions(bytes);
+	if (format === void 0 || dimensions === void 0) {
+		state.context.sink({
+			code: require_diagnostics.EpubDiagnosticCodes.IMAGE_FORMAT_UNSUPPORTED,
+			severity: "warning",
+			message: `<img src="${src}"> is neither a PNG nor a JPEG (document-schema.js's ContentImageBlock supports only those two); degraded to its alt text`,
+			href: state.context.sourceHref
+		});
+		return alt === void 0 || alt.length === 0 ? void 0 : decorateParagraph({
+			kind: "paragraph",
+			runs: [{ text: require_xml_entities.decodeEntities(alt) }]
+		}, state);
+	}
+	return {
+		kind: "image",
+		format,
+		base64: require_util_base64.bytesToBase64(bytes),
+		widthPt: dimensions.widthPx * require_image_dimensions.POINTS_PER_PIXEL,
+		heightPt: dimensions.heightPx * require_image_dimensions.POINTS_PER_PIXEL,
+		...alt !== void 0 && alt.length > 0 ? { altText: require_xml_entities.decodeEntities(alt) } : {}
+	};
+}
+function readAside(element, state) {
+	if (!require_xhtml_footnote.isFootnoteAside(element)) return readContainerChildren(element.children, state);
+	const name = require_xml_query.attrValue(element, "id");
+	if (name === void 0) {
+		state.context.sink({
+			code: require_diagnostics.EpubDiagnosticCodes.FOOTNOTE_TARGET_UNRESOLVED,
+			severity: "warning",
+			message: "a footnote <aside> carries no id and cannot be referenced; read as ordinary content",
+			href: state.context.sourceHref
+		});
+		return readContainerChildren(element.children, state);
+	}
+	return [
+		{
+			kind: "constructStart",
+			descriptor: {
+				kind: "anchor",
+				anchorType: "footnote",
+				name
+			}
+		},
+		...readContainerChildren(element.children, state),
+		{ kind: "constructEnd" }
+	];
+}
+//#endregion
+exports.readXhtmlBody = readXhtmlBody;

package/dist/xhtml/read.d.cts

@@ -0,0 +1,20 @@
+import { ContentBlock, SourceResidue } from "document-schema.js";
+//#region src/xhtml/read.d.ts
+interface ReadXhtmlBodyOptions {
+  readonly resolveImage: (href: string) => Uint8Array<ArrayBuffer> | undefined;
+  readonly sink: (diagnostic: {
+    code: string;
+    severity: "info" | "warning";
+    message: string;
+    href?: string;
+  }) => void;
+  readonly sourceHref: string;
+  readonly contentWidthPt: number;
+}
+interface ReadXhtmlBodyResult {
+  readonly blocks: ContentBlock[];
+  readonly source: SourceResidue | undefined;
+}
+declare function readXhtmlBody(xml: string, options: ReadXhtmlBodyOptions): ReadXhtmlBodyResult;
+//#endregion
+export { ReadXhtmlBodyOptions, ReadXhtmlBodyResult, readXhtmlBody };

package/dist/xhtml/read.d.ts

@@ -0,0 +1,20 @@
+import { ContentBlock, SourceResidue } from "document-schema.js";
+//#region src/xhtml/read.d.ts
+interface ReadXhtmlBodyOptions {
+  readonly resolveImage: (href: string) => Uint8Array<ArrayBuffer> | undefined;
+  readonly sink: (diagnostic: {
+    code: string;
+    severity: "info" | "warning";
+    message: string;
+    href?: string;
+  }) => void;
+  readonly sourceHref: string;
+  readonly contentWidthPt: number;
+}
+interface ReadXhtmlBodyResult {
+  readonly blocks: ContentBlock[];
+  readonly source: SourceResidue | undefined;
+}
+declare function readXhtmlBody(xml: string, options: ReadXhtmlBodyOptions): ReadXhtmlBodyResult;
+//#endregion
+export { ReadXhtmlBodyOptions, ReadXhtmlBodyResult, readXhtmlBody };