@korzun/epubcheck-ts 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,1427 @@
+import { unzipSync } from "fflate";
+import { SaxesParser } from "saxes";
+import * as csstree from "css-tree";
+//#region package.json
+var version = "0.1.0-beta.0";
+//#endregion
+//#region src/messages/catalog.ts
+/**
+* Message catalog (id -> severity + template), porting epubcheck's message
+* vocabulary. Templates use positional placeholders: %1$s, %2$s, ...
+* This plan seeds only the OCF/container + internal ids; later plans extend it.
+*/
+const CATALOG = {
+	"PKG-001": {
+		severity: "WARNING",
+		template: "Validating the EPUB against version %1$s but detected version %2$s."
+	},
+	"PKG-003": {
+		severity: "FATAL",
+		template: "The EPUB could not be read: %1$s"
+	},
+	"PKG-005": {
+		severity: "ERROR",
+		template: "The mimetype file must not be compressed."
+	},
+	"PKG-006": {
+		severity: "ERROR",
+		template: "The mimetype file entry is missing or is not the first file in the archive."
+	},
+	"PKG-007": {
+		severity: "ERROR",
+		template: "The mimetype file contains an incorrect value; expected 'application/epub+zip'."
+	},
+	"RSC-002": {
+		severity: "FATAL",
+		template: "The required META-INF/container.xml resource could not be found."
+	},
+	"RSC-003": {
+		severity: "ERROR",
+		template: "No rootfile with media type 'application/oebps-package+xml' was found in META-INF/container.xml."
+	},
+	"RSC-005": {
+		severity: "ERROR",
+		template: "Error while parsing file '%1$s': %2$s"
+	},
+	"RSC-006": {
+		severity: "ERROR",
+		template: "Remote resource reference is not allowed in this context; resource \"%1$s\" must be located in the EPUB container."
+	},
+	"RSC-007": {
+		severity: "ERROR",
+		template: "Referenced resource \"%1$s\" could not be found in the EPUB."
+	},
+	"RSC-008": {
+		severity: "ERROR",
+		template: "Referenced resource \"%1$s\" is not declared in the OPF manifest."
+	},
+	"RSC-010": {
+		severity: "ERROR",
+		template: "Reference to non-standard resource type found."
+	},
+	"RSC-011": {
+		severity: "ERROR",
+		template: "Found a reference to a resource that is not a spine item."
+	},
+	"RSC-012": {
+		severity: "ERROR",
+		template: "Fragment identifier is not defined."
+	},
+	"OPF-001": {
+		severity: "ERROR",
+		template: "There was an error when parsing the EPUB version: %1$s"
+	},
+	"OPF-003": {
+		severity: "USAGE",
+		template: "Item \"%1$s\" exists in the EPUB, but is not declared in the OPF manifest."
+	},
+	"OPF-030": {
+		severity: "ERROR",
+		template: "The unique-identifier \"%1$s\" was not found."
+	},
+	"OPF-033": {
+		severity: "ERROR",
+		template: "The spine contains no linear resources."
+	},
+	"OPF-048": {
+		severity: "ERROR",
+		template: "Package tag is missing its required unique-identifier attribute and value."
+	},
+	"OPF-049": {
+		severity: "ERROR",
+		template: "Item id \"%1$s\" was not found in the manifest."
+	},
+	"OPF-074": {
+		severity: "ERROR",
+		template: "Package resource \"%1$s\" is declared in several manifest item."
+	},
+	"RSC-001": {
+		severity: "ERROR",
+		template: "File \"%1$s\" could not be found."
+	},
+	"NAV-010": {
+		severity: "ERROR",
+		template: "\"%1$s\" nav must not link to remote resources; found link to \"%2$s\"."
+	},
+	"NAV-011": {
+		severity: "WARNING",
+		template: "\"%1$s\" nav must be in reading order; link target \"%2$s\" is before the previous link's target in %3$s order."
+	},
+	"CHK-001": {
+		severity: "FATAL",
+		template: "An internal error occurred while validating: %1$s"
+	},
+	"CSS-001": {
+		severity: "ERROR",
+		template: "The \"%1$s\" property must not be included in an EPUB Style Sheet."
+	},
+	"CSS-002": {
+		severity: "ERROR",
+		template: "Empty or NULL reference found."
+	},
+	"CSS-003": {
+		severity: "WARNING",
+		template: "CSS document is encoded in UTF-16. It should be encoded in UTF-8 instead."
+	},
+	"CSS-004": {
+		severity: "ERROR",
+		template: "CSS documents must be encoded in UTF-8, detected %1$s;"
+	},
+	"CSS-005": {
+		severity: "USAGE",
+		template: "Conflicting alternate style tags found: %1$s."
+	},
+	"CSS-006": {
+		severity: "USAGE",
+		template: "CSS selector specifies fixed position."
+	},
+	"CSS-007": {
+		severity: "INFO",
+		template: "Font-face reference \"%1$s\" refers to non-standard font type \"%2$s\"."
+	},
+	"CSS-008": {
+		severity: "ERROR",
+		template: "An error occurred while parsing the CSS: %1$s."
+	},
+	"CSS-015": {
+		severity: "ERROR",
+		template: "Alternative style sheets must have a title."
+	},
+	"CSS-019": {
+		severity: "WARNING",
+		template: "CSS font-face declaration has no attributes."
+	},
+	"RSC-013": {
+		severity: "ERROR",
+		template: "Fragment identifier is used in a reference to a stylesheet resource."
+	},
+	"RSC-030": {
+		severity: "ERROR",
+		template: "File URLs are not allowed in EPUB, but found \"%1$s\"."
+	},
+	"RSC-031": {
+		severity: "WARNING",
+		template: "Remote resource references should use HTTPS, but found \"%1$s\"."
+	},
+	"RSC-032": {
+		severity: "ERROR",
+		template: "Fallback must be provided for foreign resources, but found none for resource \"%1$s\" of type \"%2$s\"."
+	}
+};
+//#endregion
+//#region src/messages/format.ts
+/** Replace %N$s placeholders (1-based) with the corresponding argument. */
+function applyTemplate(template, args) {
+	return template.replace(/%(\d+)\$s/g, (_match, n) => {
+		const value = args[Number(n) - 1];
+		return value === void 0 ? "" : String(value);
+	});
+}
+function msg(id, location, ...args) {
+	const entry = CATALOG[id];
+	if (!entry) return {
+		id,
+		severity: "ERROR",
+		message: `Unknown message id ${id}${args.length ? ` (${args.join(", ")})` : ""}`,
+		location
+	};
+	return {
+		id,
+		severity: entry.severity,
+		message: applyTemplate(entry.template, args),
+		location
+	};
+}
+//#endregion
+//#region src/io/xml.ts
+function decode(bytes) {
+	const text = new TextDecoder("utf-8").decode(bytes);
+	return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function parseXml(bytes, path) {
+	const parser = new SaxesParser({
+		xmlns: true,
+		position: true
+	});
+	const messages = [];
+	const document = {
+		type: "element",
+		children: [],
+		loc: { path }
+	};
+	const stack = [document];
+	parser.on("opentag", (tag) => {
+		const attrs = {};
+		for (const [key, value] of Object.entries(tag.attributes)) attrs[key] = value.value;
+		const node = {
+			type: "element",
+			name: tag.local,
+			ns: tag.uri || void 0,
+			attrs,
+			children: [],
+			loc: {
+				path,
+				line: parser.line,
+				column: parser.column
+			}
+		};
+		stack[stack.length - 1].children.push(node);
+		stack.push(node);
+	});
+	parser.on("text", (value) => {
+		if (value.trim() === "") return;
+		stack[stack.length - 1].children.push({
+			type: "text",
+			text: value,
+			loc: { path }
+		});
+	});
+	parser.on("closetag", (_tag) => {
+		stack.pop();
+	});
+	let failed = false;
+	parser.on("error", (err) => {
+		if (failed) return;
+		failed = true;
+		messages.push(msg("RSC-005", {
+			path,
+			line: parser.line,
+			column: parser.column
+		}, path, err.message));
+	});
+	try {
+		parser.write(decode(bytes)).close();
+	} catch {}
+	if (failed) return { messages };
+	return {
+		root: document.children[0],
+		messages
+	};
+}
+/** Element children of a node (text nodes filtered out). */
+function childElements(node) {
+	return (node.children ?? []).filter((c) => c.type === "element");
+}
+/** All descendant elements (any depth) whose local name matches. */
+function findDescendants(node, localName) {
+	const out = [];
+	const walk = (n) => {
+		for (const child of n.children ?? []) if (child.type === "element") {
+			if (child.name === localName) out.push(child);
+			walk(child);
+		}
+	};
+	walk(node);
+	return out;
+}
+/** All descendant text content of a node, concatenated (not trimmed). */
+function textContent(node) {
+	let out = "";
+	const walk = (n) => {
+		for (const child of n.children ?? []) if (child.type === "text") out += child.text ?? "";
+		else walk(child);
+	};
+	walk(node);
+	return out;
+}
+//#endregion
+//#region src/io/zip.ts
+async function toBytes(input) {
+	if (input instanceof Uint8Array) return input;
+	if (input instanceof ArrayBuffer) return new Uint8Array(input);
+	const reader = input.getReader();
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		total += value.byteLength;
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+/**
+* Walk the ZIP central directory to recover entry order and compression method.
+* Returns names in directory order with method (0 = stored, 8 = deflate).
+*/
+function readCentralDirectory(bytes) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let eocd = -1;
+	for (let i = bytes.length - 22; i >= 0; i--) if (view.getUint32(i, true) === 101010256) {
+		eocd = i;
+		break;
+	}
+	if (eocd < 0) throw new Error("Not a ZIP archive: missing end-of-central-directory record");
+	const count = view.getUint16(eocd + 10, true);
+	let p = view.getUint32(eocd + 16, true);
+	const decoder = new TextDecoder("utf-8");
+	const entries = [];
+	for (let i = 0; i < count; i++) {
+		if (view.getUint32(p, true) !== 33639248) break;
+		const method = view.getUint16(p + 10, true);
+		const nameLen = view.getUint16(p + 28, true);
+		const extraLen = view.getUint16(p + 30, true);
+		const commentLen = view.getUint16(p + 32, true);
+		const name = decoder.decode(bytes.subarray(p + 46, p + 46 + nameLen));
+		entries.push({
+			name,
+			method
+		});
+		p += 46 + nameLen + extraLen + commentLen;
+	}
+	return entries;
+}
+async function openEpub(input) {
+	const bytes = await toBytes(input);
+	const order = readCentralDirectory(bytes);
+	const content = unzipSync(bytes);
+	const resources = /* @__PURE__ */ new Map();
+	for (const { name, method } of order) {
+		if (name.endsWith("/")) continue;
+		const data = content[name];
+		if (!data) continue;
+		resources.set(name, {
+			path: name,
+			bytes: data,
+			compression: method === 0 ? "stored" : "deflate"
+		});
+	}
+	return {
+		resources,
+		rootfiles: extractRootfiles(resources),
+		hasEncryption: resources.has("META-INF/encryption.xml")
+	};
+}
+function extractRootfiles(resources) {
+	const container = resources.get("META-INF/container.xml");
+	if (!container) return [];
+	const { root } = parseXml(container.bytes, "META-INF/container.xml");
+	if (!root) return [];
+	return findDescendants(root, "rootfile").filter((rf) => rf.attrs?.["media-type"] === "application/oebps-package+xml").map((rf) => rf.attrs?.["full-path"]).filter((path) => typeof path === "string");
+}
+function getResource(container, path) {
+	return container.resources.get(path);
+}
+//#endregion
+//#region src/checks/ocf.ts
+const MIMETYPE = "mimetype";
+const EPUB_MEDIA_TYPE = "application/epub+zip";
+const CONTAINER_PATH = "META-INF/container.xml";
+function validateOcf(container) {
+	const messages = [];
+	const firstKey = container.resources.keys().next().value;
+	const mimetype = getResource(container, MIMETYPE);
+	if (firstKey !== MIMETYPE || !mimetype) messages.push(msg("PKG-006", { path: MIMETYPE }));
+	if (mimetype) {
+		if (mimetype.compression !== "stored") messages.push(msg("PKG-005", { path: MIMETYPE }));
+		if (new TextDecoder("utf-8").decode(mimetype.bytes) !== EPUB_MEDIA_TYPE) messages.push(msg("PKG-007", { path: MIMETYPE }));
+	}
+	if (!getResource(container, CONTAINER_PATH)) messages.push(msg("RSC-002", { path: CONTAINER_PATH }));
+	else if (container.rootfiles.length === 0) messages.push(msg("RSC-003", { path: CONTAINER_PATH }));
+	return messages;
+}
+//#endregion
+//#region src/util/path.ts
+/**
+* Resolve an href that appears inside `fromFile` to a normalized container path.
+* Strips fragment/query, decodes percent-encoding, normalizes "." and "..".
+* A leading "/" is container-root-relative.
+*/
+function resolvePath(fromFile, href) {
+	const clean = (href.split("#")[0] ?? "").split("?")[0] ?? "";
+	let decoded;
+	try {
+		decoded = decodeURIComponent(clean);
+	} catch {
+		decoded = clean;
+	}
+	const absolute = decoded.startsWith("/");
+	const target = absolute ? decoded.slice(1) : decoded;
+	const baseDir = fromFile.includes("/") ? fromFile.slice(0, fromFile.lastIndexOf("/")) : "";
+	const stack = absolute || baseDir === "" ? [] : baseDir.split("/");
+	for (const part of target.split("/")) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") stack.pop();
+		else stack.push(part);
+	}
+	return stack.join("/");
+}
+/** True when `href` is an absolute URL with a scheme (e.g. https://…). */
+function isRemote(href) {
+	return /^[a-z][a-z0-9+.-]*:\/\//i.test(href);
+}
+/** True when `url` carries any scheme (https:, data:, mailto:, …). */
+function hasScheme(url) {
+	return /^[a-z][a-z0-9+.-]*:/i.test(url);
+}
+//#endregion
+//#region src/parse/opf.ts
+const DC_NS = "http://purl.org/dc/elements/1.1/";
+function firstChild(node, localName) {
+	return childElements(node).find((c) => c.name === localName);
+}
+function splitProps(value) {
+	return value ? value.trim().split(/\s+/).filter(Boolean) : [];
+}
+function textOf(node) {
+	return (node.children ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("").trim();
+}
+function parseOpf(container) {
+	const messages = [];
+	const opfPath = container.rootfiles[0];
+	if (!opfPath) return { messages };
+	const resource = getResource(container, opfPath);
+	if (!resource) {
+		messages.push(msg("RSC-001", { path: opfPath }, opfPath));
+		return { messages };
+	}
+	const parsed = parseXml(resource.bytes, opfPath);
+	messages.push(...parsed.messages);
+	const root = parsed.root;
+	if (!root || root.name !== "package") return { messages };
+	const metadataEl = firstChild(root, "metadata");
+	const manifestEl = firstChild(root, "manifest");
+	const spineEl = firstChild(root, "spine");
+	const metadata = {
+		identifiers: [],
+		titles: [],
+		languages: [],
+		modifiedCount: 0
+	};
+	if (metadataEl) {
+		for (const el of childElements(metadataEl)) if (el.ns === DC_NS && el.name === "identifier") metadata.identifiers.push({
+			id: el.attrs?.["id"],
+			value: textOf(el)
+		});
+		else if (el.ns === DC_NS && el.name === "title") metadata.titles.push(textOf(el));
+		else if (el.ns === DC_NS && el.name === "language") metadata.languages.push(textOf(el));
+		else if (el.name === "meta" && el.attrs?.["property"] === "dcterms:modified" && !el.attrs["refines"]) metadata.modifiedCount++;
+	}
+	const manifest = manifestEl ? childElements(manifestEl).filter((el) => el.name === "item").map((el) => ({
+		id: el.attrs?.["id"],
+		href: el.attrs?.["href"],
+		mediaType: el.attrs?.["media-type"],
+		properties: splitProps(el.attrs?.["properties"]),
+		fallback: el.attrs?.["fallback"],
+		loc: el.loc
+	})) : [];
+	const spine = spineEl ? childElements(spineEl).filter((el) => el.name === "itemref").map((el) => ({
+		idref: el.attrs?.["idref"],
+		linear: el.attrs?.["linear"] !== "no",
+		properties: splitProps(el.attrs?.["properties"]),
+		loc: el.loc
+	})) : [];
+	return {
+		pkg: {
+			path: opfPath,
+			version: root.attrs?.["version"],
+			uniqueIdentifier: root.attrs?.["unique-identifier"],
+			metadata,
+			manifest,
+			spinePresent: spineEl !== void 0,
+			spine,
+			loc: root.loc
+		},
+		messages
+	};
+}
+/** Resolved-container-path → manifest item, for non-remote manifest hrefs. */
+function manifestPathMap(pkg) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of pkg.manifest) if (item.href && !isRemote(item.href)) map.set(resolvePath(pkg.path, item.href), item);
+	return map;
+}
+//#endregion
+//#region src/checks/opf.ts
+const XHTML_MEDIA_TYPE = "application/xhtml+xml";
+function validateOpf(pkg, container) {
+	return [
+		...checkPackage(pkg),
+		...checkManifest(pkg, container),
+		...checkSpineAndNav(pkg)
+	];
+}
+/**
+* OPF-003: a container resource that is not declared in the manifest.
+* Excludes `mimetype`, everything under `META-INF/`, and the rootfile package
+* document(s). (epubcheck also exempts EPUB 3 OPF `<link>` resources and the
+* Multiple-Renditions mapping document, which we do not model.)
+*/
+function checkUndeclaredResources(pkg, container) {
+	const messages = [];
+	const declared = manifestPathMap(pkg);
+	const rootfiles = new Set(container.rootfiles);
+	for (const path of container.resources.keys()) {
+		if (path === "mimetype") continue;
+		if (path.startsWith("META-INF/")) continue;
+		if (rootfiles.has(path)) continue;
+		if (declared.has(path)) continue;
+		messages.push(msg("OPF-003", { path }, path));
+	}
+	return messages;
+}
+function checkPackage(pkg) {
+	const messages = [];
+	const loc = pkg.loc;
+	if (!pkg.version) messages.push(msg("OPF-001", loc, "the version attribute is missing"));
+	else if (pkg.version !== "2.0" && pkg.version !== "3.0") messages.push(msg("OPF-001", loc, `unsupported version "${pkg.version}"`));
+	if (!pkg.uniqueIdentifier) messages.push(msg("OPF-048", loc));
+	else if (!pkg.metadata.identifiers.some((i) => i.id === pkg.uniqueIdentifier)) messages.push(msg("OPF-030", loc, pkg.uniqueIdentifier));
+	if (pkg.metadata.identifiers.length === 0) messages.push(msg("RSC-005", loc, pkg.path, "The package metadata must include at least one dc:identifier element."));
+	if (pkg.metadata.titles.length === 0) messages.push(msg("RSC-005", loc, pkg.path, "The package metadata must include at least one dc:title element."));
+	if (pkg.metadata.languages.length === 0) messages.push(msg("RSC-005", loc, pkg.path, "The package metadata must include at least one dc:language element."));
+	if (pkg.metadata.modifiedCount !== 1) messages.push(msg("RSC-005", loc, pkg.path, "The package dcterms:modified meta element must occur exactly once."));
+	return messages;
+}
+function checkManifest(pkg, container) {
+	const messages = [];
+	const seenIds = /* @__PURE__ */ new Set();
+	const seenPaths = /* @__PURE__ */ new Set();
+	for (const item of pkg.manifest) {
+		if (!item.id || !item.href || !item.mediaType) messages.push(msg("RSC-005", item.loc, pkg.path, "A manifest item is missing a required attribute (id, href, and media-type are required)."));
+		if (item.id) if (seenIds.has(item.id)) messages.push(msg("RSC-005", item.loc, pkg.path, `Duplicate manifest item id "${item.id}".`));
+		else seenIds.add(item.id);
+		if (item.href && !isRemote(item.href)) {
+			const resolved = resolvePath(pkg.path, item.href);
+			if (seenPaths.has(resolved)) messages.push(msg("OPF-074", item.loc, resolved));
+			else seenPaths.add(resolved);
+			if (!getResource(container, resolved)) messages.push(msg("RSC-001", item.loc, resolved));
+		}
+	}
+	return messages;
+}
+function checkSpineAndNav(pkg) {
+	const messages = [];
+	if (!pkg.spinePresent) messages.push(msg("RSC-005", pkg.loc, pkg.path, "The package document must contain a spine element."));
+	else if (pkg.spine.length === 0) messages.push(msg("RSC-005", pkg.loc, pkg.path, "The spine element must contain at least one itemref."));
+	else {
+		const ids = new Set(pkg.manifest.map((i) => i.id).filter((id) => Boolean(id)));
+		for (const ref of pkg.spine) if (ref.idref && !ids.has(ref.idref)) messages.push(msg("OPF-049", ref.loc, ref.idref));
+		if (!pkg.spine.some((s) => s.linear)) messages.push(msg("OPF-033", pkg.loc));
+	}
+	if (pkg.version === "3.0") {
+		const navItems = pkg.manifest.filter((i) => i.properties.includes("nav"));
+		if (navItems.length !== 1) messages.push(msg("RSC-005", pkg.loc, pkg.path, `Exactly one manifest item must declare the "nav" property (number of "nav" items: ${navItems.length}).`));
+		else {
+			const nav = navItems[0];
+			if (nav && nav.mediaType !== XHTML_MEDIA_TYPE) messages.push(msg("RSC-005", nav.loc, pkg.path, `The manifest item representing the Navigation Document must be of the "${XHTML_MEDIA_TYPE}" type (given type was "${nav.mediaType ?? ""}").`));
+		}
+	}
+	return messages;
+}
+//#endregion
+//#region src/parse/nav.ts
+const EPUB_TYPE_ATTR = "epub:type";
+function tokens(value) {
+	return value ? value.trim().split(/\s+/).filter(Boolean) : [];
+}
+function parseNav(navItem, container) {
+	const messages = [];
+	const opfPath = container.rootfiles[0];
+	if (!opfPath || !navItem.href) return { messages };
+	const navPath = resolvePath(opfPath, navItem.href);
+	const resource = getResource(container, navPath);
+	if (!resource) return { messages };
+	const parsed = parseXml(resource.bytes, navPath);
+	messages.push(...parsed.messages);
+	const root = parsed.root;
+	if (!root) return { messages };
+	return {
+		nav: {
+			path: navPath,
+			root,
+			sections: findDescendants(root, "nav").map((node) => ({
+				types: tokens(node.attrs?.[EPUB_TYPE_ATTR]),
+				node,
+				loc: node.loc
+			})),
+			loc: root.loc
+		},
+		messages
+	};
+}
+//#endregion
+//#region src/parse/content.ts
+/** Extract the URL of each srcset candidate ("url descriptor, url descriptor"). */
+function parseSrcset(value) {
+	return value.split(",").map((part) => part.trim().split(/\s+/)[0] ?? "").filter((u) => u !== "");
+}
+function addRefs(el, parent, attrs, refs) {
+	const push = (url, type, intrinsic = false) => {
+		if (url) refs.push({
+			url,
+			type,
+			loc: el.loc,
+			hasIntrinsicFallback: intrinsic
+		});
+	};
+	const pushAll = (urls, type, intrinsic = false) => {
+		for (const url of urls) refs.push({
+			url,
+			type,
+			loc: el.loc,
+			hasIntrinsicFallback: intrinsic
+		});
+	};
+	const inPicture = parent === "picture";
+	switch (el.name) {
+		case "a":
+		case "area":
+			push(attrs["href"] ?? attrs["xlink:href"], "hyperlink");
+			break;
+		case "img":
+			push(attrs["src"], "image", inPicture);
+			if (attrs["srcset"]) pushAll(parseSrcset(attrs["srcset"]), "image", inPicture);
+			break;
+		case "image":
+			push(attrs["xlink:href"] ?? attrs["href"], "image");
+			break;
+		case "source":
+			if (attrs["srcset"]) pushAll(parseSrcset(attrs["srcset"]), "image", inPicture);
+			else if (parent === "audio") push(attrs["src"], "audio", true);
+			else if (parent === "video") push(attrs["src"], "video", false);
+			else push(attrs["src"], "image", true);
+			break;
+		case "audio":
+			push(attrs["src"], "audio");
+			break;
+		case "video":
+			push(attrs["src"], "video");
+			push(attrs["poster"], "image");
+			break;
+		case "track":
+			push(attrs["src"], "track");
+			break;
+		case "link":
+			if ((attrs["rel"] ?? "").split(/\s+/).includes("stylesheet")) push(attrs["href"], "stylesheet");
+			break;
+		case "script":
+			push(attrs["src"], "generic");
+			break;
+		case "object":
+			push(attrs["data"], "generic", true);
+			break;
+		case "iframe":
+		case "embed":
+		case "input":
+			push(attrs["src"], "generic");
+			break;
+		case "blockquote":
+		case "q":
+		case "ins":
+		case "del":
+			push(attrs["cite"], "cite");
+			break;
+		case "math":
+			push(attrs["altimg"], "image");
+			break;
+		default: break;
+	}
+}
+function collect(node, parent, refs, ids, idPositions, inlineStyles) {
+	for (const child of node.children ?? []) {
+		if (child.type !== "element") continue;
+		const attrs = child.attrs ?? {};
+		const id = attrs["id"];
+		if (id) {
+			ids.add(id);
+			if (!idPositions.has(id)) idPositions.set(id, idPositions.size + 1);
+		}
+		addRefs(child, parent, attrs, refs);
+		if (child.name === "style") inlineStyles.push({
+			context: "stylesheet",
+			text: textContent(child),
+			loc: child.loc
+		});
+		const styleAttr = attrs["style"];
+		if (styleAttr) inlineStyles.push({
+			context: "declarationList",
+			text: styleAttr,
+			loc: child.loc
+		});
+		collect(child, child.name, refs, ids, idPositions, inlineStyles);
+	}
+}
+function parseContent(item, container) {
+	const messages = [];
+	const opfPath = container.rootfiles[0];
+	if (!opfPath || !item.href) return { messages };
+	const path = resolvePath(opfPath, item.href);
+	const resource = getResource(container, path);
+	if (!resource) return { messages };
+	const parsed = parseXml(resource.bytes, path);
+	messages.push(...parsed.messages);
+	const root = parsed.root;
+	if (!root) return { messages };
+	const refs = [];
+	const ids = /* @__PURE__ */ new Set();
+	const idPositions = /* @__PURE__ */ new Map();
+	const inlineStyles = [];
+	collect(root, void 0, refs, ids, idPositions, inlineStyles);
+	return {
+		doc: {
+			path,
+			root,
+			refs,
+			ids,
+			idPositions,
+			inlineStyles
+		},
+		messages
+	};
+}
+//#endregion
+//#region src/checks/nav.ts
+function hasType(section, type) {
+	return section.types.includes(type);
+}
+function validateNav(nav, pkg, container) {
+	return [
+		...checkOccurrence(nav),
+		...checkContent(nav),
+		...checkLinks(nav),
+		...checkReadingOrder(nav, pkg, container)
+	];
+}
+function checkOccurrence(nav) {
+	const messages = [];
+	const tocs = nav.sections.filter((s) => hasType(s, "toc"));
+	if (tocs.length !== 1) messages.push(msg("RSC-005", nav.loc, nav.path, "Exactly one \"toc\" nav element must be present."));
+	if (nav.sections.filter((s) => hasType(s, "page-list")).length > 1) messages.push(msg("RSC-005", nav.loc, nav.path, "Multiple occurrences of the \"page-list\" nav element."));
+	if (nav.sections.filter((s) => hasType(s, "landmarks")).length > 1) messages.push(msg("RSC-005", nav.loc, nav.path, "Multiple occurrences of the \"landmarks\" nav element."));
+	const toc = tocs[0];
+	if (toc && findDescendants(toc.node, "ol").length === 0) messages.push(msg("RSC-005", toc.loc, nav.path, "The \"toc\" nav element must contain an ol element."));
+	return messages;
+}
+function checkLinks(nav) {
+	const messages = [];
+	for (const section of nav.sections) {
+		const label = section.types[0] ?? "toc";
+		for (const a of findDescendants(section.node, "a")) {
+			const href = a.attrs?.["href"];
+			if (href && isRemote(href)) messages.push(msg("NAV-010", a.loc, label, href));
+		}
+	}
+	return messages;
+}
+function anchorPosition(href, idPositions) {
+	const hash = href.indexOf("#");
+	const fragment = hash < 0 ? "" : href.slice(hash + 1);
+	if (fragment.trim() === "") return 0;
+	return idPositions.get(fragment) ?? -1;
+}
+function checkReadingOrder(nav, pkg, container) {
+	const messages = [];
+	const itemById = /* @__PURE__ */ new Map();
+	for (const item of pkg.manifest) if (item.id !== void 0) itemById.set(item.id, item);
+	const spinePos = /* @__PURE__ */ new Map();
+	pkg.spine.forEach((s, i) => {
+		if (s.idref === void 0) return;
+		const item = itemById.get(s.idref);
+		if (item?.href && !isRemote(item.href)) spinePos.set(resolvePath(pkg.path, item.href), i);
+	});
+	const manifest = manifestPathMap(pkg);
+	const idPosCache = /* @__PURE__ */ new Map();
+	const idPositionsFor = (path) => {
+		const cached = idPosCache.get(path);
+		if (cached) return cached;
+		const item = manifest.get(path);
+		const positions = item ? parseContent(item, container).doc?.idPositions ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map();
+		idPosCache.set(path, positions);
+		return positions;
+	};
+	for (const section of nav.sections) {
+		if (!hasType(section, "toc")) continue;
+		let lastSpinePos = -1;
+		let lastAnchorPos = -1;
+		for (const a of findDescendants(section.node, "a")) {
+			const href = a.attrs?.["href"];
+			if (!href || isRemote(href)) continue;
+			const target = resolvePath(nav.path, href);
+			const pos = spinePos.get(target);
+			if (pos === void 0) continue;
+			if (pos < lastSpinePos) {
+				messages.push(msg("NAV-011", a.loc, "toc", target, "spine"));
+				lastSpinePos = pos;
+				lastAnchorPos = -1;
+			} else {
+				if (pos > lastSpinePos) {
+					lastSpinePos = pos;
+					lastAnchorPos = -1;
+				}
+				const anchorPos = anchorPosition(href, idPositionsFor(target));
+				if (anchorPos > -1) {
+					if (anchorPos < lastAnchorPos) messages.push(msg("NAV-011", a.loc, "toc", target, "document"));
+					lastAnchorPos = anchorPos;
+				}
+			}
+		}
+	}
+	return messages;
+}
+function checkContent(nav) {
+	const messages = [];
+	for (const section of nav.sections) {
+		const anchors = findDescendants(section.node, "a");
+		for (const a of anchors) {
+			if (!a.attrs?.["href"]) messages.push(msg("RSC-005", a.loc, nav.path, "An \"a\" element in the navigation document must have an href attribute."));
+			if (textContent(a).trim() === "") messages.push(msg("RSC-005", a.loc, nav.path, "Anchors within nav elements must contain text."));
+		}
+		for (const span of findDescendants(section.node, "span")) if (textContent(span).trim() === "") messages.push(msg("RSC-005", span.loc, nav.path, "Spans within nav elements must contain text."));
+		if (hasType(section, "landmarks")) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const a of anchors) {
+				const type = a.attrs?.["epub:type"];
+				if (!type) {
+					messages.push(msg("RSC-005", a.loc, nav.path, "Missing epub:type attribute on anchor inside \"landmarks\" nav element."));
+					continue;
+				}
+				const href = a.attrs?.["href"] ?? "";
+				const key = `${type}::${href}`;
+				if (seen.has(key)) messages.push(msg("RSC-005", a.loc, nav.path, `Another landmark was found with the same epub:type and reference to "${href}".`));
+				else seen.add(key);
+			}
+		}
+	}
+	return messages;
+}
+//#endregion
+//#region src/util/html-elements.ts
+/** Local names of HTML5 elements (the conforming element vocabulary). */
+const KNOWN_HTML_ELEMENTS = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"address",
+	"area",
+	"article",
+	"aside",
+	"audio",
+	"b",
+	"base",
+	"bdi",
+	"bdo",
+	"blockquote",
+	"body",
+	"br",
+	"button",
+	"canvas",
+	"caption",
+	"cite",
+	"code",
+	"col",
+	"colgroup",
+	"data",
+	"datalist",
+	"dd",
+	"del",
+	"details",
+	"dfn",
+	"dialog",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"embed",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"head",
+	"header",
+	"hgroup",
+	"hr",
+	"html",
+	"i",
+	"iframe",
+	"img",
+	"input",
+	"ins",
+	"kbd",
+	"label",
+	"legend",
+	"li",
+	"link",
+	"main",
+	"map",
+	"mark",
+	"menu",
+	"meta",
+	"meter",
+	"nav",
+	"noscript",
+	"object",
+	"ol",
+	"optgroup",
+	"option",
+	"output",
+	"p",
+	"param",
+	"picture",
+	"pre",
+	"progress",
+	"q",
+	"rb",
+	"rp",
+	"rt",
+	"rtc",
+	"ruby",
+	"s",
+	"samp",
+	"script",
+	"section",
+	"select",
+	"slot",
+	"small",
+	"source",
+	"span",
+	"strong",
+	"style",
+	"sub",
+	"summary",
+	"sup",
+	"table",
+	"tbody",
+	"td",
+	"template",
+	"textarea",
+	"tfoot",
+	"th",
+	"thead",
+	"time",
+	"title",
+	"tr",
+	"track",
+	"u",
+	"ul",
+	"var",
+	"video",
+	"wbr"
+]);
+function isKnownHtmlElement(name) {
+	return KNOWN_HTML_ELEMENTS.has(name);
+}
+//#endregion
+//#region src/parse/css.ts
+function locOf(node, path) {
+	const start = node?.loc?.start;
+	return start ? {
+		path,
+		line: start.line,
+		column: start.column
+	} : { path };
+}
+function stripQuotes(raw) {
+	const t = raw.trim();
+	if (t.length >= 2 && (t.startsWith("\"") && t.endsWith("\"") || t.startsWith("'") && t.endsWith("'"))) return t.slice(1, -1);
+	return t;
+}
+/**
+* Extract the URL string from a css-tree Url node.
+* In v3, node.value is already a plain string with quotes stripped by the parser.
+*/
+function urlValue(node) {
+	return stripQuotes(node.value);
+}
+/** The import target from an @import at-rule prelude (Url or String). */
+function importTarget(atrule) {
+	const prelude = atrule.prelude;
+	if (!prelude || prelude.type !== "AtrulePrelude") return void 0;
+	let result;
+	csstree.walk(prelude, (n) => {
+		if (result !== void 0) return;
+		if (n.type === "Url") result = urlValue(n);
+		else if (n.type === "String") result = stripQuotes(n.value);
+	});
+	return result;
+}
+function countDeclarations(atrule) {
+	let count = 0;
+	if (atrule.block) csstree.walk(atrule.block, (n) => {
+		if (n.type === "Declaration") count++;
+	});
+	return count;
+}
+function analyzeCss(text, path, context) {
+	const messages = [];
+	const refs = [];
+	const declarations = [];
+	const fontFaces = [];
+	let ast;
+	try {
+		ast = csstree.parse(text, {
+			positions: true,
+			context,
+			onParseError(error) {
+				messages.push(msg("CSS-008", {
+					path,
+					line: error.line,
+					column: error.column
+				}, error.message));
+			}
+		});
+	} catch (error) {
+		messages.push(msg("CSS-008", { path }, error instanceof Error ? error.message : String(error)));
+		return {
+			parsed: false,
+			refs,
+			declarations,
+			fontFaces,
+			messages
+		};
+	}
+	const atruleStack = [];
+	const pushRef = (url, type, loc) => {
+		if (url.trim() === "") messages.push(msg("CSS-002", loc));
+		else refs.push({
+			url,
+			type,
+			loc
+		});
+	};
+	csstree.walk(ast, {
+		enter: (node) => {
+			if (node.type === "Atrule") {
+				const atrule = node;
+				if (atrule.name === "import") {
+					const url = importTarget(atrule);
+					if (url !== void 0) pushRef(url, "import", locOf(atrule, path));
+				} else if (atrule.name === "font-face") fontFaces.push({
+					declarationCount: countDeclarations(atrule),
+					loc: locOf(atrule, path)
+				});
+				atruleStack.push(atrule.name);
+			} else if (node.type === "Url") {
+				if (atruleStack[atruleStack.length - 1] !== "import") {
+					const urlNode = node;
+					const type = atruleStack[atruleStack.length - 1] === "font-face" ? "font" : "generic";
+					pushRef(urlValue(urlNode), type, locOf(urlNode, path));
+				}
+			} else if (node.type === "Declaration") {
+				const decl = node;
+				declarations.push({
+					property: decl.property.toLowerCase(),
+					value: csstree.generate(decl.value),
+					loc: locOf(decl, path)
+				});
+			}
+		},
+		leave: (node) => {
+			if (node.type === "Atrule") atruleStack.pop();
+		}
+	});
+	return {
+		parsed: true,
+		refs,
+		declarations,
+		fontFaces,
+		messages
+	};
+}
+/**
+* Detect a CSS file's declared encoding from a leading BOM or an `@charset`
+* rule (which, per the CSS syntax, must be the very first bytes). Returns the
+* lowercased encoding name, or undefined when none is declared (assume UTF-8).
+*/
+function detectCssCharset(bytes) {
+	if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) return "utf-16be";
+	if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254) return "utf-16le";
+	if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) return "utf-8";
+	const prefix = "@charset \"";
+	let head = "";
+	for (let i = 0; i < Math.min(bytes.length, 100); i++) head += String.fromCharCode(bytes[i] ?? 0);
+	if (head.startsWith(prefix)) {
+		const end = head.indexOf("\"", 10);
+		if (end > 10) return head.slice(10, end).toLowerCase();
+	}
+}
+function parseCss(item, container) {
+	const opfPath = container.rootfiles[0];
+	if (!opfPath || !item.href) return { messages: [] };
+	const path = resolvePath(opfPath, item.href);
+	const resource = getResource(container, path);
+	if (!resource) return { messages: [] };
+	const charset = detectCssCharset(resource.bytes);
+	if (charset !== void 0 && charset !== "utf-8") return { messages: [charset.startsWith("utf-16") ? msg("CSS-003", { path }) : msg("CSS-004", { path }, charset)] };
+	const a = analyzeCss(new TextDecoder("utf-8").decode(resource.bytes), path, "stylesheet");
+	if (!a.parsed) return { messages: a.messages };
+	return {
+		css: {
+			path,
+			refs: a.refs,
+			declarations: a.declarations,
+			fontFaces: a.fontFaces
+		},
+		messages: a.messages
+	};
+}
+//#endregion
+//#region src/util/media-types.ts
+/** EPUB 3 blessed font media types (epubcheck OPFChecker30.isBlessedFontType). */
+const BLESSED_FONT_TYPES = /* @__PURE__ */ new Set([
+	"font/ttf",
+	"font/otf",
+	"font/woff",
+	"font/woff2",
+	"application/font-sfnt",
+	"application/vnd.ms-opentype",
+	"application/font-woff",
+	"application/x-font-ttf"
+]);
+function isBlessedFontType(mediaType) {
+	return mediaType !== void 0 && BLESSED_FONT_TYPES.has(mediaType);
+}
+//#endregion
+//#region src/checks/css.ts
+function validateCss(css, container, manifest) {
+	return [...checkReferences$1(css, container, manifest), ...checkProperties(css)];
+}
+function validateCssDocs(pkg, container) {
+	const messages = [];
+	const manifest = manifestPathMap(pkg);
+	for (const item of pkg.manifest) {
+		if (item.mediaType !== "text/css") continue;
+		const { css, messages: m } = parseCss(item, container);
+		messages.push(...m);
+		if (css) messages.push(...validateCss(css, container, manifest));
+	}
+	return messages;
+}
+function checkProperties(css) {
+	const messages = [];
+	for (const decl of css.declarations) if (decl.property === "direction" || decl.property === "unicode-bidi") messages.push(msg("CSS-001", decl.loc, decl.property));
+	else if (decl.property === "position" && /\bfixed\b/i.test(decl.value)) messages.push(msg("CSS-006", decl.loc));
+	for (const fontFace of css.fontFaces) if (fontFace.declarationCount === 0) messages.push(msg("CSS-019", fontFace.loc));
+	return messages;
+}
+function checkReferences$1(css, container, manifest) {
+	const messages = [];
+	for (const ref of css.refs) {
+		const url = ref.url;
+		if (/^file:/i.test(url)) {
+			messages.push(msg("RSC-030", ref.loc, url));
+			continue;
+		}
+		if (ref.type === "import" && url.includes("#")) messages.push(msg("RSC-013", ref.loc));
+		if (isRemote(url)) {
+			if (ref.type === "font") {
+				if (!/^https:\/\//i.test(url)) messages.push(msg("RSC-031", ref.loc, url));
+			} else messages.push(msg("RSC-006", ref.loc, url));
+			continue;
+		}
+		if (hasScheme(url)) continue;
+		const target = resolvePath(css.path, url);
+		if (!getResource(container, target)) messages.push(msg("RSC-007", ref.loc, url));
+		else if (!manifest.has(target)) messages.push(msg("RSC-008", ref.loc, url));
+		else if (ref.type === "font") {
+			const item = manifest.get(target);
+			if (item && item.mediaType !== void 0 && !isBlessedFontType(item.mediaType)) messages.push(msg("CSS-007", ref.loc, url, item.mediaType));
+		}
+	}
+	return messages;
+}
+//#endregion
+//#region src/checks/content.ts
+const REMOTE_ALLOWED = /* @__PURE__ */ new Set([
+	"hyperlink",
+	"cite",
+	"audio",
+	"video"
+]);
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+const BLESSED_CONTENT_TYPES = /* @__PURE__ */ new Set([
+	"application/xhtml+xml",
+	"image/svg+xml",
+	"text/x-oeb1-document",
+	"text/html"
+]);
+function isBlessedContentType(mediaType) {
+	return mediaType !== void 0 && BLESSED_CONTENT_TYPES.has(mediaType);
+}
+const CORE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+	"image/gif",
+	"image/jpeg",
+	"image/png",
+	"image/webp",
+	"image/svg+xml",
+	"audio/mpeg",
+	"audio/mp4",
+	...BLESSED_FONT_TYPES,
+	"application/xhtml+xml",
+	"text/javascript",
+	"application/javascript",
+	"application/ecmascript",
+	"text/css",
+	"application/pls+xml",
+	"application/smil+xml"
+]);
+function isCoreMediaType(mediaType) {
+	if (mediaType === void 0) return false;
+	if (CORE_MEDIA_TYPES.has(mediaType)) return true;
+	if (mediaType.startsWith("video/")) return true;
+	if (/^audio\/ogg\s*;\s*codecs=opus$/i.test(mediaType)) return true;
+	return false;
+}
+function hasFallbackTo(item, byId, predicate) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = item.fallback;
+	while (current !== void 0 && !seen.has(current)) {
+		seen.add(current);
+		const next = byId.get(current);
+		if (next === void 0) return false;
+		if (predicate(next)) return true;
+		current = next.fallback;
+	}
+	return false;
+}
+function hasFallbackToBlessed(item, byId) {
+	return hasFallbackTo(item, byId, (i) => isBlessedContentType(i.mediaType));
+}
+function validateContentDocs(pkg, container) {
+	const messages = [];
+	const manifest = manifestPathMap(pkg);
+	const byId = /* @__PURE__ */ new Map();
+	for (const item of pkg.manifest) if (item.id !== void 0) byId.set(item.id, item);
+	const spinePaths = /* @__PURE__ */ new Set();
+	for (const s of pkg.spine) {
+		if (s.idref === void 0) continue;
+		const item = byId.get(s.idref);
+		if (item?.href && !isRemote(item.href)) spinePaths.add(resolvePath(pkg.path, item.href));
+	}
+	const docs = /* @__PURE__ */ new Map();
+	for (const item of pkg.manifest) {
+		if (item.mediaType !== "application/xhtml+xml") continue;
+		const { doc, messages: m } = parseContent(item, container);
+		messages.push(...m);
+		if (doc) docs.set(doc.path, doc);
+	}
+	for (const doc of docs.values()) {
+		messages.push(...checkReferences(doc, container, manifest, byId, spinePaths));
+		messages.push(...checkFragments(doc, docs, manifest));
+		messages.push(...checkElements(doc));
+		messages.push(...checkLinkElements(doc));
+		for (const style of doc.inlineStyles) {
+			const a = analyzeCss(style.text, doc.path, style.context);
+			messages.push(...a.messages);
+			messages.push(...validateCss({
+				path: doc.path,
+				refs: a.refs,
+				declarations: a.declarations,
+				fontFaces: a.fontFaces
+			}, container, manifest));
+		}
+	}
+	return messages;
+}
+function isFragmentCheckable(mediaType) {
+	return mediaType === "application/xhtml+xml";
+}
+function checkFragments(doc, docs, manifest) {
+	const messages = [];
+	for (const ref of doc.refs) {
+		const hash = ref.url.indexOf("#");
+		if (hash < 0) continue;
+		const frag = ref.url.slice(hash + 1);
+		if (frag === "") continue;
+		const base = ref.url.slice(0, hash);
+		let ids;
+		if (base === "") ids = doc.ids;
+		else {
+			if (isRemote(ref.url) || hasScheme(base)) continue;
+			const target = resolvePath(doc.path, base);
+			const item = manifest.get(target);
+			if (!item || !isFragmentCheckable(item.mediaType)) continue;
+			ids = docs.get(target)?.ids;
+			if (!ids) continue;
+		}
+		if (!ids.has(frag)) messages.push(msg("RSC-012", ref.loc));
+	}
+	return messages;
+}
+function checkElements(doc) {
+	const messages = [];
+	const walk = (node) => {
+		for (const child of node.children ?? []) {
+			if (child.type !== "element") continue;
+			const name = child.name ?? "";
+			if (child.ns === HTML_NS && !name.includes("-") && !isKnownHtmlElement(name)) messages.push(msg("RSC-005", child.loc, doc.path, `Unknown element "${name}" in the XHTML namespace.`));
+			walk(child);
+		}
+	};
+	walk(doc.root);
+	return messages;
+}
+const ALTCSS_CONFLICTS = [["vertical", "horizontal"], ["day", "night"]];
+function checkLinkElements(doc) {
+	const messages = [];
+	for (const link of findDescendants(doc.root, "link")) {
+		if (link.ns !== HTML_NS) continue;
+		const attrs = link.attrs ?? {};
+		const rel = (attrs["rel"] ?? "").split(/\s+/).filter(Boolean);
+		if (rel.includes("alternate") && rel.includes("stylesheet") && (attrs["title"] ?? "").trim() === "") messages.push(msg("CSS-015", link.loc));
+		const classes = new Set((attrs["class"] ?? "").split(/\s+/).filter(Boolean));
+		if (ALTCSS_CONFLICTS.some(([a, b]) => classes.has(a) && classes.has(b))) messages.push(msg("CSS-005", link.loc, attrs["class"] ?? ""));
+	}
+	return messages;
+}
+function checkReferences(doc, container, manifest, byId, spinePaths) {
+	const messages = [];
+	for (const ref of doc.refs) {
+		const url = ref.url;
+		if (url.startsWith("#")) continue;
+		if (isRemote(url)) {
+			if (!REMOTE_ALLOWED.has(ref.type)) messages.push(msg("RSC-006", ref.loc, url));
+			else if (ref.type !== "hyperlink") {
+				const scheme = url.slice(0, url.indexOf(":")).toLowerCase();
+				if (scheme !== "https" && scheme !== "file") messages.push(msg("RSC-031", ref.loc, url));
+			}
+			continue;
+		}
+		if (hasScheme(url)) continue;
+		const target = resolvePath(doc.path, url);
+		if (!getResource(container, target)) messages.push(msg("RSC-007", ref.loc, url));
+		else if (!manifest.has(target)) messages.push(msg("RSC-008", ref.loc, url));
+		else if (ref.type === "hyperlink") {
+			const item = manifest.get(target);
+			if (item) {
+				if (!isBlessedContentType(item.mediaType) && !hasFallbackToBlessed(item, byId)) messages.push(msg("RSC-010", ref.loc));
+				else if (!spinePaths.has(target)) messages.push(msg("RSC-011", ref.loc));
+			}
+		} else if (ref.type === "image" || ref.type === "audio" || ref.type === "video" || ref.type === "generic") {
+			const item = manifest.get(target);
+			if (item && !ref.hasIntrinsicFallback && !isCoreMediaType(item.mediaType) && !hasFallbackTo(item, byId, (i) => isCoreMediaType(i.mediaType))) messages.push(msg("RSC-032", ref.loc, target, item.mediaType ?? ""));
+		}
+	}
+	return messages;
+}
+//#endregion
+//#region src/report.ts
+function buildReport(messages, epubVersion) {
+	const counts = {
+		FATAL: 0,
+		ERROR: 0,
+		WARNING: 0,
+		INFO: 0,
+		USAGE: 0
+	};
+	for (const message of messages) counts[message.severity]++;
+	return {
+		messages,
+		epubVersion,
+		counts,
+		fatal: counts.FATAL > 0,
+		valid: counts.FATAL === 0 && counts.ERROR === 0
+	};
+}
+//#endregion
+//#region src/validate.ts
+async function validateEpub(input, options = {}) {
+	const messages = [];
+	try {
+		const container = await openEpub(input);
+		messages.push(...validateOcf(container));
+		const { pkg, messages: opfMessages } = parseOpf(container);
+		messages.push(...opfMessages);
+		let detectedVersion;
+		if (pkg) {
+			messages.push(...validateOpf(pkg, container));
+			messages.push(...checkUndeclaredResources(pkg, container));
+			if (pkg.version === "2.0") detectedVersion = "2.0";
+			else if (pkg.version === "3.0") detectedVersion = "3.0";
+			if (options.version && detectedVersion && options.version !== detectedVersion) messages.push(msg("PKG-001", pkg.loc, options.version, detectedVersion));
+			if (detectedVersion === "3.0") {
+				const navItem = pkg.manifest.find((i) => i.properties.includes("nav"));
+				if (navItem) {
+					const { nav, messages: navMessages } = parseNav(navItem, container);
+					messages.push(...navMessages);
+					if (nav) messages.push(...validateNav(nav, pkg, container));
+				}
+				messages.push(...validateContentDocs(pkg, container));
+				messages.push(...validateCssDocs(pkg, container));
+			}
+		}
+		return buildReport(messages, options.version ?? detectedVersion);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		const id = /zip/i.test(reason) ? "PKG-003" : "CHK-001";
+		messages.push(msg(id, void 0, reason));
+		return buildReport(messages, options.version);
+	}
+}
+//#endregion
+//#region src/index.ts
+const VERSION = version;
+//#endregion
+export { VERSION, analyzeCss, buildReport, childElements, findDescendants, getResource, msg, openEpub, parseContent, parseCss, parseNav, parseOpf, parseXml, textContent, validateContentDocs, validateCss, validateCssDocs, validateEpub, validateNav, validateOcf, validateOpf };