@storyteller-platform/epub 0.8.1 → 1.0.0

package/dist/upgrade.js

@@ -1,6 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@storyteller-platform/epub/jsx-runtime";
 import { nanoid } from "nanoid";
 import { MediaType } from "@storyteller-platform/media-types";
-import { Epub, } from "./index.js";
+import { findXmlChildByNameNS, findXmlDescendantByName, findXmlDescendantByNameNS, insert, NS, replace, serialize, text, x, } from "./xml.js";
 const GUIDE_TO_EPUBTYPE = {
     acknowledgements: "acknowledgments",
     "other.afterword": "afterword",
@@ -50,54 +51,52 @@ const GUIDE_TO_EPUBTYPE = {
 const XHTML_MEDIA_TYPES = new Set([MediaType.XHTML, MediaType.HTML]);
 // xml helpers
 function getMetadataElement(pkg) {
-    return Epub.findXmlChildByName("metadata", Epub.getXmlChildren(pkg));
+    return findXmlChildByNameNS(NS.opf, "metadata", pkg);
 }
 function getManifestElement(pkg) {
-    return Epub.findXmlChildByName("manifest", Epub.getXmlChildren(pkg));
+    return findXmlChildByNameNS(NS.opf, "manifest", pkg);
 }
 function getSpineElement(pkg) {
-    return Epub.findXmlChildByName("spine", Epub.getXmlChildren(pkg));
+    return findXmlChildByNameNS(NS.opf, "spine", pkg);
+}
+/**
+ * Replace an outdated document type declaration with `<!DOCTYPE html>`.
+ *
+ * EPUB 3 XHTML content documents must conform to the HTML5 conformance
+ * criteria, which require `<!DOCTYPE html>`.
+ */
+export function normalizeDoctype(doc) {
+    const doctype = doc.doctype;
+    if (doctype && doctype.publicId === "" && doctype.systemId === "")
+        return;
+    if (doctype)
+        doc.removeChild(doctype);
+    doc.insertBefore(doc.implementation.createDocumentType("html", "", ""), doc.documentElement);
+    return;
 }
 function ensureId(element) {
-    const existing = element[":@"]?.["@_id"];
+    const existing = element.getAttribute("id");
     if (existing)
         return existing;
     const id = `id-${nanoid(8)}`;
-    element[":@"] ??= {};
-    element[":@"]["@_id"] = id;
+    element.setAttribute("id", id);
     return id;
 }
-function findAllByName(name, xml) {
-    return xml.filter((node) => !Epub.isXmlTextNode(node) && name in node);
-}
-function hasElementDeep(xml, name) {
-    for (const node of xml) {
-        if (Epub.isXmlTextNode(node))
-            continue;
-        if (Epub.getXmlElementName(node) === name)
-            return true;
-        if (hasElementDeep(Epub.getXmlChildren(node), name))
-            return true;
-    }
-    return false;
-}
-function textContentOf(element) {
-    return Epub.getXhtmlTextContent(Epub.getXmlChildren(element)).trim();
+function findAllByNameNS(namespaceUri, name, element) {
+    return element.children.filter((node) => (!namespaceUri || node.namespaceURI === namespaceUri) &&
+        node.localName === name);
 }
-function removeFromArray(array, item) {
-    const idx = array.indexOf(item);
-    if (idx !== -1)
-        array.splice(idx, 1);
+function findAllByName(name, element) {
+    return findAllByNameNS(null, name, element);
 }
 // ---------------------------------------------------------------------------
 export function upgradeIdentifiers(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    for (const ident of findAllByName("dc:identifier", metadata.metadata)) {
-        const attrs = ident[":@"] ?? {};
-        let val = textContentOf(ident);
-        let scheme = attrs["@_opf:scheme"];
+    for (const ident of findAllByNameNS(NS.dc, "identifier", metadata)) {
+        let val = ident.textContent ?? "";
+        let scheme = ident.getAttributeNS(NS.opf, "scheme");
         if (val.toLowerCase().startsWith("urn:")) {
             const rest = val.slice(4);
             const colonIdx = rest.indexOf(":");
@@ -109,21 +108,20 @@ export function upgradeIdentifiers(pkg) {
         if (scheme && val && !scheme.toLowerCase().startsWith("uri")) {
             val = `${scheme}:${val}`;
         }
-        const id = attrs["@_id"];
-        ident[":@"] = id ? { "@_id": id } : {};
-        Epub.replaceXmlChildren(ident, [Epub.createXmlTextNode(val)]);
+        const id = ident.getAttribute("id");
+        replace(metadata, _jsx("dc:identifier", { id: id, children: val }), ident);
     }
 }
 export function upgradeTitle(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    const titles = findAllByName("dc:title", metadata.metadata);
+    const titles = findAllByNameNS(NS.dc, "title", metadata);
     let firstTitle = null;
     for (const title of titles) {
-        const text = textContentOf(title);
+        const text = title.textContent?.trim();
         if (!text) {
-            removeFromArray(metadata.metadata, title);
+            metadata.removeChild(title);
             continue;
         }
         firstTitle ??= title;
@@ -131,43 +129,38 @@ export function upgradeTitle(pkg) {
     if (!firstTitle)
         return;
     const titleId = ensureId(firstTitle);
-    metadata.metadata.push(Epub.createXmlElement("meta", { refines: `#${titleId}`, property: "title-type" }, [Epub.createXmlTextNode("main")]));
+    insert(metadata, _jsx("meta", { refines: `#${titleId}`, property: "title-type", children: "main" }));
 }
 export function upgradeLanguages(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    const langs = findAllByName("dc:language", metadata.metadata);
+    const langs = findAllByNameNS(NS.dc, "language", metadata);
     if (langs.length > 0) {
         for (const lang of langs) {
-            const id = lang[":@"]?.["@_id"];
-            lang[":@"] = id ? { "@_id": id } : {};
+            const id = lang.getAttribute("id");
+            replace(metadata, _jsx("dc:language", { id: id, children: Array.from(lang.childNodes) }), lang);
         }
         return;
     }
-    metadata.metadata.push(Epub.createXmlElement("dc:language", {}, [Epub.createXmlTextNode("und")]));
+    insert(metadata, _jsx("dc:language", { children: "und" }));
 }
 export function upgradeAuthors(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    for (const which of ["dc:creator", "dc:contributor"]) {
-        for (const elem of findAllByName(which, metadata.metadata)) {
-            const attrs = elem[":@"] ?? {};
-            const role = attrs["@_opf:role"];
-            const sort = attrs["@_opf:file-as"];
-            const elemId = role || sort ? ensureId(elem) : attrs["@_id"];
+    for (const which of ["creator", "contributor"]) {
+        for (const elem of findAllByNameNS(NS.dc, which, metadata)) {
+            const role = elem.getAttributeNS(NS.opf, "role");
+            const sort = elem.getAttributeNS(NS.opf, "file-as");
+            const elemId = role || sort ? ensureId(elem) : elem.getAttribute("id");
             // strip all non-id attributes
-            elem[":@"] = elemId ? { "@_id": elemId } : {};
+            replace(metadata, x(`dc:${which}`, elemId === null ? null : { id: elemId }, ...elem.childNodes), elem);
             if (role) {
-                metadata.metadata.push(Epub.createXmlElement("meta", {
-                    refines: `#${elemId}`,
-                    property: "role",
-                    scheme: "marc:relators",
-                }, [Epub.createXmlTextNode(role)]));
+                insert(metadata, _jsx("meta", { refines: `#${elemId}`, property: "role", scheme: "marc:relators", children: role }));
             }
             if (sort) {
-                metadata.metadata.push(Epub.createXmlElement("meta", { refines: `#${elemId}`, property: "file-as" }, [Epub.createXmlTextNode(sort)]));
+                insert(metadata, _jsx("meta", { refines: `#${elemId}`, property: "file-as", children: sort }));
             }
         }
     }
@@ -176,27 +169,26 @@ export function upgradeDate(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    const dates = findAllByName("dc:date", metadata.metadata);
+    const dates = findAllByNameNS(NS.dc, "date", metadata);
     let kept = false;
     for (const date of dates) {
-        const text = textContentOf(date);
+        const text = date.textContent;
         if (!text || kept) {
-            removeFromArray(metadata.metadata, date);
+            metadata.removeChild(date);
             continue;
         }
         kept = true;
-        const id = date[":@"]?.["@_id"];
-        date[":@"] = id ? { "@_id": id } : {};
+        const id = date.getAttribute("id");
+        replace(metadata, _jsx("dc:date", { id: id, children: Array.from(date.childNodes) }), date);
     }
 }
 export function upgradeMeta(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    for (const meta of findAllByName("meta", metadata.metadata)) {
-        const attrs = meta[":@"] ?? {};
-        const name = attrs["@_name"] ?? "";
-        const content = attrs["@_content"] ?? "";
+    for (const meta of findAllByName("meta", metadata)) {
+        const name = meta.getAttribute("name") ?? "";
+        const content = meta.getAttribute("content") ?? "";
         let prop = null;
         let value = content;
         const cleanName = name.startsWith("rendition:")
@@ -219,10 +211,13 @@ export function upgradeMeta(pkg) {
         }
         if (!prop)
             continue;
-        delete attrs["@_name"];
-        delete attrs["@_content"];
-        attrs["@_property"] = prop;
-        Epub.replaceXmlChildren(meta, [Epub.createXmlTextNode(value)]);
+        meta.removeAttribute("name");
+        meta.removeAttribute("content");
+        meta.setAttribute("property", prop);
+        while (meta.firstChild) {
+            meta.removeChild(meta.firstChild);
+        }
+        insert(meta, text(value));
     }
 }
 export function upgradeCover(pkg) {
@@ -230,27 +225,26 @@ export function upgradeCover(pkg) {
     const manifest = getManifestElement(pkg);
     if (!metadata || !manifest)
         return;
-    for (const meta of findAllByName("meta", metadata.metadata)) {
-        const attrs = meta[":@"];
-        const isCoverMeta = attrs?.["@_name"] === "cover" && attrs["@_content"];
+    for (const meta of findAllByName("meta", metadata)) {
+        const content = meta.getAttribute("content");
+        const isCoverMeta = meta.getAttribute("name") === "cover" && content;
         if (!isCoverMeta)
             continue;
-        const itemId = attrs["@_content"];
-        for (const item of findAllByName("item", manifest.manifest)) {
-            const itemAttrs = item[":@"];
-            if (!itemAttrs || itemAttrs["@_id"] !== itemId)
+        const itemId = content;
+        for (const item of findAllByName("item", manifest)) {
+            if (item.getAttribute("id") !== itemId)
                 continue;
-            const mediaType = (itemAttrs["@_media-type"] ?? "").toLowerCase();
+            const mediaType = (item.getAttribute("media-type") ?? "").toLowerCase();
             // only mark actual images, not html wrappers
             const isImage = mediaType && !mediaType.includes("xml") && !mediaType.includes("html");
             if (!isImage)
                 continue;
-            const existing = (itemAttrs["@_properties"] ?? "")
+            const existing = (item.getAttribute("properties") ?? "")
                 .split(" ")
                 .filter(Boolean);
             const props = new Set(existing);
             props.add("cover-image");
-            itemAttrs["@_properties"] = [...props].sort().join(" ");
+            item.setAttribute("properties", [...props].sort().join(" "));
         }
     }
 }
@@ -258,35 +252,27 @@ export function removeInvalidDcAttrs(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    for (const node of metadata.metadata) {
-        if (Epub.isXmlTextNode(node))
-            continue;
-        const name = Epub.getXmlElementName(node);
-        if (!name.startsWith("dc:"))
+    for (const node of Array.from(metadata.children)) {
+        if (node.namespaceURI !== NS.dc)
             continue;
-        const attrs = node[":@"];
-        if (!attrs)
-            continue;
-        const id = attrs["@_id"];
-        node[":@"] = id ? { "@_id": id } : {};
+        for (const attr of Array.from(node.attributes)) {
+            if (attr.name === "id" || attr.name.startsWith("xmlns:"))
+                continue;
+            node.removeAttributeNode(attr);
+        }
     }
 }
 export function setLastModified(pkg) {
     const metadata = getMetadataElement(pkg);
     if (!metadata)
         return;
-    for (let i = metadata.metadata.length - 1; i >= 0; i--) {
-        const node = metadata.metadata[i];
-        if (!node || Epub.isXmlTextNode(node))
-            continue;
-        if (node[":@"]?.["@_property"] === "dcterms:modified") {
-            metadata.metadata.splice(i, 1);
+    for (const node of Array.from(metadata.children)) {
+        if (node.getAttribute("property") === "dcterms:modified") {
+            metadata.removeChild(node);
         }
     }
     const now = new Date().toISOString().replace(/\.\d+/, "");
-    metadata.metadata.push(Epub.createXmlElement("meta", { property: "dcterms:modified" }, [
-        Epub.createXmlTextNode(now),
-    ]));
+    insert(metadata, _jsx("meta", { property: "dcterms:modified", children: now }));
 }
 export function upgradePackageMetadata(pkg) {
     upgradeIdentifiers(pkg);
@@ -300,19 +286,16 @@ export function upgradePackageMetadata(pkg) {
     setLastModified(pkg);
 }
 export function extractGuideLandmarks(pkg) {
-    const guide = Epub.findXmlChildByName("guide", Epub.getXmlChildren(pkg));
+    const guide = findXmlChildByNameNS(NS.opf, "guide", pkg);
     if (!guide)
         return [];
     const landmarks = [];
-    for (const node of Epub.getXmlChildren(guide)) {
-        if (Epub.isXmlTextNode(node))
-            continue;
+    for (const node of Array.from(guide.children)) {
         if (!("reference" in node))
             continue;
-        const attrs = node[":@"] ?? {};
-        const href = attrs["@_href"] ?? "";
-        const title = attrs["@_title"] ?? "";
-        const guideType = (attrs["@_type"] ?? "").toLowerCase();
+        const href = node.getAttribute("href") ?? "";
+        const title = node.getAttribute("title") ?? "";
+        const guideType = (node.getAttribute("type") ?? "").toLowerCase();
         const epubType = GUIDE_TO_EPUBTYPE[guideType];
         if (epubType === undefined || !href)
             continue;
@@ -321,17 +304,14 @@ export function extractGuideLandmarks(pkg) {
     return landmarks;
 }
 export function removeGuide(pkg) {
-    const children = Epub.getXmlChildren(pkg);
-    const guide = Epub.findXmlChildByName("guide", children);
+    const guide = findXmlChildByNameNS(NS.opf, "guide", pkg);
     if (guide) {
-        removeFromArray(children, guide);
+        pkg.removeChild(guide);
     }
 }
 export function removeSpineTocRef(pkg) {
     const spine = getSpineElement(pkg);
-    if (!spine?.[":@"])
-        return;
-    delete spine[":@"]["@_toc"];
+    spine?.removeAttribute("toc");
 }
 export async function collectManifestProperties(epub) {
     const manifest = await epub.getManifest();
@@ -339,22 +319,25 @@ export async function collectManifestProperties(epub) {
         const mediaType = MediaType.fromMime(item.mediaType ?? "");
         if (!mediaType || !XHTML_MEDIA_TYPES.has(mediaType))
             continue;
-        let xml;
+        let documentElement;
         try {
-            xml = await epub.readXhtmlItemContents(item.id);
+            documentElement = (await epub.readXhtmlItemContents(item.id))
+                .documentElement;
         }
         catch {
             continue;
         }
+        if (!documentElement)
+            continue;
         const props = new Set(item.properties ?? []);
         const before = props.size;
-        if (hasElementDeep(xml, "svg"))
+        if (findXmlDescendantByName("svg", documentElement))
             props.add("svg");
-        if (hasElementDeep(xml, "script"))
+        if (findXmlDescendantByName("script", documentElement))
             props.add("scripted");
-        if (hasElementDeep(xml, "math"))
+        if (findXmlDescendantByName("math", documentElement))
             props.add("mathml");
-        if (hasElementDeep(xml, "epub:switch"))
+        if (findXmlDescendantByNameNS(NS.epub, "switch", documentElement))
             props.add("switch");
         if (props.size === before)
             continue;
@@ -368,15 +351,14 @@ export function fixFontMimeTypes(pkg) {
     const manifest = getManifestElement(pkg);
     if (!manifest)
         return;
-    for (const item of findAllByName("item", manifest.manifest)) {
-        const declared = item[":@"]?.["@_media-type"] ?? "";
+    for (const item of findAllByName("item", manifest)) {
+        const declared = item.getAttribute("media-type") ?? "";
         if (!MediaType.fromMime(declared)?.is("font"))
             continue;
-        const corrected = MediaType.fromPath(item[":@"]?.["@_href"] ?? "");
+        const corrected = MediaType.fromPath(item.getAttribute("href") ?? "");
         if (!corrected?.is("font") || corrected.mime === declared)
             continue;
-        item[":@"] ??= {};
-        item[":@"]["@_media-type"] = corrected.mime;
+        item.setAttribute("media-type", corrected.mime);
     }
 }
 export function buildTocOl(entries) {
@@ -384,19 +366,17 @@ export function buildTocOl(entries) {
         const label = entry.title.replace(/\s+/g, " ").trim();
         const liChildren = [];
         if (entry.href) {
-            liChildren.push(Epub.createXmlElement("a", { href: entry.href }, [
-                Epub.createXmlTextNode(label),
-            ]));
+            liChildren.push(_jsx("a", { href: entry.href, children: label }));
         }
         else {
-            liChildren.push(Epub.createXmlElement("span", {}, [Epub.createXmlTextNode(label)]));
+            liChildren.push(_jsx("span", { children: label }));
         }
         if (entry.children && entry.children.length > 0) {
             liChildren.push(buildTocOl(entry.children));
         }
-        return Epub.createXmlElement("li", {}, liChildren);
+        return _jsx("li", { children: liChildren });
     });
-    return Epub.createXmlElement("ol", {}, children);
+    return _jsx("ol", { children: children });
 }
 export async function buildNavDocument(epub, tocEntries, landmarks) {
     let tocOl;
@@ -407,41 +387,21 @@ export async function buildNavDocument(epub, tocEntries, landmarks) {
         // epub 3 requires a non-empty <ol>, fall back to first spine item
         const spineItems = await epub.getSpineItems();
         const firstHref = spineItems[0]?.href ?? "#";
-        tocOl = Epub.createXmlElement("ol", {}, [
-            Epub.createXmlElement("li", {}, [
-                Epub.createXmlElement("a", { href: firstHref }, [
-                    Epub.createXmlTextNode("Start"),
-                ]),
-            ]),
-        ]);
+        tocOl = (_jsx("ol", { children: _jsx("li", { children: _jsx("a", { href: firstHref, children: "Start" }) }) }));
     }
-    const tocNav = Epub.createXmlElement("nav", { "epub:type": "toc" }, [
-        Epub.createXmlElement("h1", {}, [
-            Epub.createXmlTextNode("Table of Contents"),
-        ]),
-        tocOl,
-    ]);
-    const body = [tocNav];
+    const tocNav = (_jsxs("nav", { "epub:type": "toc", children: [_jsx("h1", { children: "Table of Contents" }), tocOl] }));
+    const bodyChildren = [tocNav];
     const validLandmarks = landmarks.filter((lm) => lm.type);
     if (validLandmarks.length > 0) {
-        const lmOl = Epub.createXmlElement("ol", {}, validLandmarks.map((lm) => Epub.createXmlElement("li", {}, [
-            Epub.createXmlElement("a", { "epub:type": lm.type, href: lm.href }, [
-                Epub.createXmlTextNode(lm.title || lm.type),
-            ]),
-        ])));
-        body.push(Epub.createXmlElement("nav", { "epub:type": "landmarks", hidden: "" }, [
-            lmOl,
-        ]));
+        const lmOl = (_jsx("ol", { children: validLandmarks.map((lm) => (_jsx("li", { children: _jsx("a", { "epub:type": lm.type, href: lm.href, children: lm.title || lm.type }) }))) }));
+        bodyChildren.push(_jsx("nav", { "epub:type": "landmarks", hidden: "", children: lmOl }));
     }
-    const head = [
-        Epub.createXmlElement("title", {}, [Epub.createXmlTextNode("Navigation")]),
-    ];
-    const navDoc = await epub.createXhtmlDocument(body, head);
-    return Epub.xhtmlBuilder.build(navDoc);
+    const head = [_jsx("title", { children: "Navigation" })];
+    const navDoc = await epub.createXhtmlDocument(bodyChildren, head);
+    return serialize(navDoc);
 }
 export function setPackageVersion(pkg, version) {
-    pkg[":@"] ??= {};
-    pkg[":@"]["@_version"] = version;
+    pkg.setAttribute("version", version);
 }
 export async function chooseNavHref(epub) {
     const manifest = await epub.getManifest();

package/dist/xml.d.ts

@@ -0,0 +1,103 @@
+import xmldom, { type Document, type CharacterData, type Element, type Node, type Text, type DocumentType } from "@xmldom/xmldom";
+export declare const XMLSerializer: typeof xmldom.XMLSerializer;
+export declare function isElement(n: Node): n is Element;
+export declare function isText(n: Node): n is CharacterData;
+export declare function isCdata(n: Node): n is CharacterData;
+export declare function isComment(n: Node): n is CharacterData;
+/**
+ * Give every element in `node`'s subtree the namespace its position implies,
+ * without overwriting any element that already has one.
+ *
+ * @privateremarks
+ *
+ * `x()` builds elements in no namespace. That serializes correctly, because a
+ * child in no namespace inherits the enclosing default namespace on the way
+ * out, but in memory the elements report `namespaceURI === null` and so are
+ * invisible to namespace-aware queries such as `getElementsByTagNameNS`.
+ * Calling this after inserting a node makes the tree report the namespace its
+ * position implies.
+ */
+export declare function adoptNamespaces(node: Element): void;
+/**
+ * Declare `uri` as the default namespace of `element` and bring the elements
+ * already under it in line with that declaration.
+ *
+ * xmldom records a namespace declaration without applying it to the tree, so a
+ * document read without `xmlns` stays in no namespace in memory even once the
+ * declaration is added. Namespace-aware lookups cannot see any of it until the
+ * subtree is fixed up, and the document element has no element parent for
+ * `adoptNamespaces` to inherit from, so it has to be bound explicitly.
+ */
+export declare function declareDefaultNamespace(element: Element, uri: string): void;
+/**
+ * Insert `child` into `parent`, then adopt its namespace.
+ *
+ * If `reference` is omitted, appends child to parent.
+ */
+export declare function insert<T extends Node>(parent: Element, child: T, reference?: Node | null): T;
+/**
+ * Replace `oldChild` with `newChild` in `parent`, then adopt the new child's
+ * namespace.
+ */
+export declare function replace<T extends Node>(parent: Element, newChild: T, oldChild: Node): T;
+/**
+ * Given an XHTML document, return the body element.
+ */
+export declare function getXhtmlBody(document: Document): Element;
+/**
+ * Given an Element, find the first child matching
+ * the provided namespace, name and optional filter.
+ */
+export declare function findXmlChildByNameNS(namespaceUri: string | null, name: string, element: Element, filter?: (node: Element) => boolean): Element | undefined;
+/**
+ * Given an Element, find the first child matching
+ * the provided name and optional filter.
+ */
+export declare function findXmlChildByName(name: string, element: Element, filter?: (node: Element) => boolean): Element | undefined;
+/**
+ * Given an Element, find the first descendant matching
+ * the provided name and optional filter.
+ *
+ * Will perform a breadth first search for the element, returning
+ * the highest element in the tree matching the name and filter.
+ */
+export declare function findXmlDescendantByNameNS(namespaceUri: string | null, name: string, element: Element, filter?: (node: Element) => boolean): Element | undefined;
+/**
+ * Given an Element, find the first descendant matching
+ * the provided name and optional filter.
+ *
+ * Will perform a breadth first search for the element, returning
+ * the highest element in the tree matching the name and filter.
+ */
+export declare function findXmlDescendantByName(name: string, element: Element, filter?: (node: Element) => boolean): Element | undefined;
+/**
+ * Given an XHTML document, add a `link` element to the
+ * `head` of the document.
+ */
+export declare function addLinkToXhtmlHead(document: Document, link: {
+    rel: string;
+    href: string;
+    type: string;
+}): void;
+export type XmlDiagnostic = {
+    level: "warning" | "error" | "fatalError";
+    message: string;
+    line?: number | undefined;
+    column?: number | undefined;
+};
+export declare function parse(xml: string, mediaType: string, onError?: (diagnostic: XmlDiagnostic) => void): Document;
+export declare function serialize(doc: Node, options?: {
+    validate?: boolean | undefined;
+}): string;
+export declare const NS: {
+    xmlns: string;
+    xml: string;
+    xhtml: string;
+    opf: string;
+    dc: string;
+    epub: string;
+};
+export declare function x(name: string, attributes?: Record<string, string | undefined> | null, ...children: Array<Node | string | null | undefined>): Element;
+export declare function text(data: string): Text;
+export declare function createDocument(namespaceUri: string | null, qualifiedName: string, docType?: DocumentType | null): Document;
+export declare function createDocumentType(qualifiedName: string, publicId?: string, systemId?: string): DocumentType;