@storyteller-platform/epub 0.7.0 → 0.7.1

package/dist/adapters/tmpfs.js

@@ -13,39 +13,23 @@ import {
   stat,
   writeFile
 } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { pipeline } from "node:stream/promises";
-import { fromBuffer, open } from "yauzl-promise";
 import { ZipFile } from "yazl";
+import { scratchPath } from "@storyteller-platform/fs";
+import { MediaType } from "@storyteller-platform/media-types";
 import { dirname, join, sep } from "@storyteller-platform/path";
-const MP3_FILE_EXTENSIONS = [".mp3"];
-const MPEG4_FILE_EXTENSIONS = [".mp4", ".m4a", ".m4b"];
-const AAC_FILE_EXTENSIONS = [".aac"];
-const OGG_FILE_EXTENSIONS = [".ogg", ".oga", ".mogg"];
-const OPUS_FILE_EXTENSIONS = [".opus"];
-const WAVE_FILE_EXTENSIONS = [".wav"];
-const AIFF_FILE_EXTENSIONS = [".aiff"];
-const FLAC_FILE_EXTENSIONS = [".flac"];
-const ALAC_FILE_EXTENSIONS = [".alac"];
-const WEBM_FILE_EXTENSIONS = [".weba"];
-const AUDIO_FILE_EXTENSIONS = [
-  ...MP3_FILE_EXTENSIONS,
-  ...AAC_FILE_EXTENSIONS,
-  ...MPEG4_FILE_EXTENSIONS,
-  ...OPUS_FILE_EXTENSIONS,
-  ...OGG_FILE_EXTENSIONS,
-  ...WAVE_FILE_EXTENSIONS,
-  ...AIFF_FILE_EXTENSIONS,
-  ...FLAC_FILE_EXTENSIONS,
-  ...ALAC_FILE_EXTENSIONS,
-  ...WEBM_FILE_EXTENSIONS
-];
-function isAudioFile(filenameOrExt) {
-  const lowered = filenameOrExt.toLowerCase();
-  return AUDIO_FILE_EXTENSIONS.some((ext) => lowered.endsWith(ext));
-}
+import { openZip } from "../zip.js";
+const PRECOMPRESSED_KINDS = /* @__PURE__ */ new Set([
+  "audio",
+  "image",
+  "archive",
+  "package"
+]);
 function mintRootPath() {
-  return join(tmpdir(), `storyteller-platform-epub-${randomUUID()}`);
+  return scratchPath(`storyteller-platform-epub-${randomUUID()}`);
+}
+function isStorableEntryName(entry) {
+  return !entry.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
 }
 class TmpFsAdapter {
   constructor(rootPath) {
@@ -58,7 +42,7 @@ class TmpFsAdapter {
     try {
       var _stack = [];
       try {
-        const zipfile = typeof source === "string" ? await open(source) : await fromBuffer(Buffer.from(source));
+        const zipfile = await openZip(source);
         const stack = __using(_stack, new AsyncDisposableStack(), true);
         stack.defer(async () => {
           await zipfile.close();
@@ -67,7 +51,8 @@ class TmpFsAdapter {
           if (entry.filename.endsWith("/")) {
             continue;
           }
-          const writePath = join(rootPath, entry.filename);
+          if (!isStorableEntryName(entry.filename)) continue;
+          const writePath = join(rootPath, ...entry.filename.split("/"));
           const readStream = await entry.openReadStream();
           await mkdir(dirname(writePath), { recursive: true });
           const writeStream = createWriteStream(writePath);
@@ -90,19 +75,36 @@ class TmpFsAdapter {
     await mkdir(rootPath, { recursive: true });
     return new TmpFsAdapter(rootPath);
   }
-  async read(path, encoding) {
-    return await readFile(path, encoding);
+  diskPath(entry) {
+    if (!isStorableEntryName(entry)) {
+      const err = new Error(`ENOENT: no such entry in EPUB archive: ${entry}`);
+      err.code = "ENOENT";
+      throw err;
+    }
+    return join(this.rootPath, ...entry.split("/"));
+  }
+  async read(entry, encoding) {
+    return await readFile(this.diskPath(entry), encoding);
   }
-  async write(path, data, encoding) {
+  async write(entry, data, encoding) {
+    const path = this.diskPath(entry);
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, data, encoding);
   }
-  async remove(path) {
-    await rm(path);
+  async remove(entry) {
+    await rm(this.diskPath(entry));
+  }
+  async exists(entry) {
+    try {
+      await stat(this.diskPath(entry));
+      return true;
+    } catch {
+      return false;
+    }
   }
-  async archiveLength(path) {
+  async archiveLength(entry) {
     try {
-      const st = await stat(path);
+      const st = await stat(this.diskPath(entry));
       return st.size;
     } catch {
       return 0;
@@ -118,7 +120,7 @@ class TmpFsAdapter {
       const absolutePath = join(entry.parentPath, entry.name);
       yield {
         absolutePath,
-        relativePath: absolutePath.replace(`${this.rootPath}${sep}`, "")
+        relativePath: absolutePath.slice(this.rootPath.length + 1).split(sep).join("/")
       };
     }
   }
@@ -133,31 +135,33 @@ class TmpFsAdapter {
     return new TmpFsAdapter(newRoot);
   }
   async serialize(targetPath) {
+    var _a;
     var _stack = [];
     try {
-      const tmpArchivePath = join(
-        tmpdir(),
-        `storyteller-platform-epub-${randomUUID()}`
-      );
-      const { promise, resolve } = Promise.withResolvers();
+      const tmpArchivePath = mintRootPath();
+      const { promise, resolve, reject } = Promise.withResolvers();
       const zipfile = new ZipFile();
       const writeStream = createWriteStream(tmpArchivePath);
       writeStream.on("close", () => {
         resolve();
       });
+      writeStream.on("error", reject);
+      zipfile.outputStream.on("error", reject);
       const stack = __using(_stack, new AsyncDisposableStack(), true);
       stack.defer(async () => {
         writeStream.close();
         await rm(tmpArchivePath, { force: true });
       });
       zipfile.outputStream.pipe(writeStream);
-      zipfile.addBuffer(Buffer.from("application/epub+zip"), "mimetype", {
+      zipfile.addBuffer(Buffer.from(MediaType.EPUB.mime), "mimetype", {
         compress: false
       });
       for await (const entry of this.list()) {
         if (entry.relativePath === "mimetype") continue;
         zipfile.addFile(entry.absolutePath, entry.relativePath, {
-          compress: !isAudioFile(entry.absolutePath)
+          compress: !PRECOMPRESSED_KINDS.has(
+            (_a = MediaType.fromPath(entry.absolutePath)) == null ? void 0 : _a.kind
+          )
         });
       }
       zipfile.end();

package/dist/epubcheck.cjs

@@ -24,15 +24,15 @@ module.exports = __toCommonJS(epubcheck_exports);
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 var import_promises = require("node:fs/promises");
-var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var import_node_url = require("node:url");
 var import_node_util = require("node:util");
+var import_fs = require("@storyteller-platform/fs");
 const import_meta = {};
 const here = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
 const JAR = (0, import_node_path.join)(here, "vendors", "epubcheck-5.3.0", "epubcheck.jar");
 async function epubcheck(epubFile) {
-  const output = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `epubcheck-${(0, import_node_crypto.randomUUID)()}.json`);
+  const output = (0, import_fs.scratchPath)(`epubcheck-${(0, import_node_crypto.randomUUID)()}.json`);
   const execFilePromise = (0, import_node_util.promisify)(import_node_child_process.execFile);
   try {
     await execFilePromise("java", [

package/dist/epubcheck.js

@@ -2,14 +2,14 @@ import "./chunk-BIEQXUOY.js";
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { readFile, unlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import { scratchPath } from "@storyteller-platform/fs";
 const here = dirname(fileURLToPath(import.meta.url));
 const JAR = join(here, "vendors", "epubcheck-5.3.0", "epubcheck.jar");
 async function epubcheck(epubFile) {
-  const output = join(tmpdir(), `epubcheck-${randomUUID()}.json`);
+  const output = scratchPath(`epubcheck-${randomUUID()}.json`);
   const execFilePromise = promisify(execFile);
   try {
     await execFilePromise("java", [

package/dist/index.cjs

@@ -40,8 +40,8 @@ var import_promises = require("node:fs/promises");
 var import_async_mutex = require("async-mutex");
 var import_fast_xml_parser = require("fast-xml-parser");
 var import_mem = __toESM(require("mem"), 1);
-var import_mime_types = require("mime-types");
 var import_nanoid = require("nanoid");
+var import_media_types = require("@storyteller-platform/media-types");
 var import_path = require("@storyteller-platform/path");
 var import_tmpfs = require("./adapters/tmpfs.cjs");
 var Upgrade = __toESM(require("./upgrade.ts"), 1);
@@ -51,6 +51,61 @@ class EpubVersionError extends Error {
 }
 class EpubReadOnlyError extends Error {
 }
+const OPF_NAMESPACE = "http://www.idpf.org/2007/opf";
+const ENTRY_ORIGIN = "epub:///";
+function entryToUrlPath(entry) {
+  return entry.split("/").map(encodeURIComponent).join("/");
+}
+function resolveEntryUrl(from, href) {
+  const base = new URL(entryToUrlPath(from), ENTRY_ORIGIN);
+  if (!URL.canParse(href, base.toString())) return null;
+  const url = new URL(href, base);
+  return url.href.startsWith(ENTRY_ORIGIN) ? url : null;
+}
+function renameOpfAttributes(attrs, prefix) {
+  const attrPrefix = `@_${prefix}:`;
+  const renamed = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (key === `@_xmlns:${prefix}`) continue;
+    if (key.startsWith(attrPrefix)) {
+      renamed[`@_opf:${key.slice(attrPrefix.length)}`] = value;
+    } else {
+      renamed[key] = value;
+    }
+  }
+  return renamed;
+}
+function stripOpfPrefix(node, prefix) {
+  if (Epub.isXmlTextNode(node)) return node;
+  const name = Epub.getXmlElementName(node);
+  const bareName = name.startsWith(`${prefix}:`) ? name.slice(prefix.length + 1) : name;
+  const element = {
+    [bareName]: Epub.getXmlChildren(node).map(
+      (child) => stripOpfPrefix(child, prefix)
+    )
+  };
+  if (node[":@"]) {
+    element[":@"] = renameOpfAttributes(node[":@"], prefix);
+  }
+  return element;
+}
+function normalizeOpfNamespacePrefixes(doc) {
+  var _a;
+  const root = doc.find(
+    (node) => !Epub.isXmlTextNode(node) && Epub.getXmlElementName(node).endsWith(":package")
+  );
+  if (!root) return doc;
+  const prefix = Epub.getXmlElementName(root).slice(0, -":package".length);
+  if (((_a = root[":@"]) == null ? void 0 : _a[`@_xmlns:${prefix}`]) !== OPF_NAMESPACE) return doc;
+  const stripped = stripOpfPrefix(root, prefix);
+  stripped[":@"] = {
+    ...stripped[":@"],
+    "@_xmlns": OPF_NAMESPACE,
+    "@_xmlns:opf": OPF_NAMESPACE
+  };
+  doc[doc.indexOf(root)] = stripped;
+  return doc;
+}
 class Epub {
   /**
    * Prefer the static factories ({@link Epub.using}, {@link Epub.from},
@@ -331,14 +386,7 @@ ${JSON.stringify(element, null, 2)}`
       );
     }
     const rootfile = await this.getRootfile();
-    const filename = this.resolveInternalHref(rootfile, href);
-    await this.adapter.remove(filename);
-  }
-  async getFileData(path, encoding) {
-    if (encoding) {
-      return this.adapter.read(path, encoding);
-    }
-    return this.adapter.read(path);
+    await this.adapter.remove(await this.resolveEntry(rootfile, href));
   }
   /**
    * Length of the underlying archive entry for a manifest item, in bytes
@@ -351,14 +399,15 @@ ${JSON.stringify(element, null, 2)}`
     const manifestItem = manifest[id];
     if (!manifestItem)
       throw new Error(`Could not find item with id "${id}" in manifest`);
-    const path = this.resolveInternalHref(rootfile, manifestItem.href);
-    return this.adapter.archiveLength(path);
+    return this.adapter.archiveLength(
+      await this.resolveEntry(rootfile, manifestItem.href)
+    );
   }
   async getRootfile() {
     var _a;
     if (this.rootfile !== null) return this.rootfile;
-    const containerString = await this.getFileData(
-      (0, import_path.join)(this.adapter.rootPath, "META-INF", "container.xml"),
+    const containerString = await this.adapter.read(
+      "META-INF/container.xml",
       "utf-8"
     );
     if (!containerString)
@@ -382,7 +431,7 @@ ${JSON.stringify(element, null, 2)}`
       Epub.getXmlChildren(rootfiles),
       (node) => {
         var _a2;
-        return !Epub.isXmlTextNode(node) && ((_a2 = node[":@"]) == null ? void 0 : _a2["@_media-type"]) === "application/oebps-package+xml";
+        return !Epub.isXmlTextNode(node) && ((_a2 = node[":@"]) == null ? void 0 : _a2["@_media-type"]) === import_media_types.MediaType.OPF.mime;
       }
     );
     const fullPath = (_a = rootfile == null ? void 0 : rootfile[":@"]) == null ? void 0 : _a["@_full-path"];
@@ -390,12 +439,12 @@ ${JSON.stringify(element, null, 2)}`
       throw new Error(
         "Failed to parse EPUB container.xml: Found no rootfile element"
       );
-    this.rootfile = (0, import_path.resolve)(this.adapter.rootPath, fullPath);
+    this.rootfile = await this.resolveEntry("", fullPath);
     return this.rootfile;
   }
   async getPackageDocument() {
     const rootfile = await this.getRootfile();
-    const packageDocumentString = await this.getFileData(rootfile, "utf-8");
+    const packageDocumentString = await this.adapter.read(rootfile, "utf-8");
     if (!packageDocumentString)
       throw new Error(
         `Failed to parse EPUB: could not find package document at ${rootfile}`
@@ -403,7 +452,7 @@ ${JSON.stringify(element, null, 2)}`
     const packageDocument = Epub.xmlParser.parse(
       packageDocumentString
     );
-    return packageDocument;
+    return normalizeOpfNamespacePrefixes(packageDocument);
   }
   async getPackageElement() {
     const packageDocument = await this.getPackageDocument();
@@ -1075,11 +1124,12 @@ ${JSON.stringify(element, null, 2)}`
    * the provided href within the publication.
    */
   async setCoverImage(href, data) {
+    var _a;
     const coverImageItem = await this.getCoverImageItem();
     if (coverImageItem) {
       await this.removeManifestItem(coverImageItem.id);
     }
-    const mediaType = (0, import_mime_types.lookup)(href);
+    const mediaType = (_a = import_media_types.MediaType.fromPath(href)) == null ? void 0 : _a.mime;
     if (!mediaType)
       throw new Error(`Invalid file extension for cover image: ${href}`);
     await this.addManifestItem(
@@ -2058,35 +2108,81 @@ ${JSON.stringify(element, null, 2)}`
     return this.getNavigation("page-list", { resolveToRoot });
   }
   /**
-   * Returns a Zip Entry path for an HREF
+   * Name the entry a resolved URL addresses.
+   *
+   * A correctly authored publication percent-encodes its hrefs, so the
+   * decoded reading is the one the spec calls for and the one we prefer.
+   * Some publications instead write the entry name verbatim, so when the two
+   * readings differ we ask the archive which one it holds. A verbatim name
+   * carrying a bare `%`, as `100%.xhtml` does, is not a valid encoding at all
+   * and can only be its own answer.
    */
-  resolveInternalHref(from, href) {
-    const startPath = (0, import_path.dirname)(from);
-    return (0, import_path.resolve)(
-      this.adapter.rootPath,
-      (0, import_path.hrefToPlatformPath)(startPath),
-      (0, import_path.hrefToPlatformPath)(href)
-    );
+  async entryForUrl(url) {
+    const asWritten = url.pathname.slice(1);
+    let decoded;
+    try {
+      decoded = decodeURIComponent(asWritten);
+    } catch {
+      return asWritten;
+    }
+    if (decoded === asWritten) {
+      return decoded;
+    }
+    if (await this.adapter.exists(decoded)) {
+      return decoded;
+    }
+    return await this.adapter.exists(asWritten) ? asWritten : decoded;
+  }
+  /**
+   * Resolve an href to the name of the archive entry it addresses.
+   *
+   * @param from The entry the href appears in; it resolves against that
+   *   entry's directory
+   * @throws when the href addresses something outside the publication
+   */
+  async resolveEntry(from, href) {
+    const url = resolveEntryUrl(from, href);
+    if (!url) {
+      throw new Error(
+        `href does not address an entry in this publication: ${href}`
+      );
+    }
+    return this.entryForUrl(url);
   }
   /**
    * Returns a path-relative-scheme-less URL, relative to the
    * container root.
    *
+   * An href that points outside the publication, such as an external link in
+   * a navigation document, is handed back unchanged.
+   *
    * @param href The href to resolve
    * @param [relativeTo] Optional - The href to resolve this href relative to.
        Use if resolving a relative href from a file other than the package document.
    */
   async resolveHref(href, relativeTo, { toRoot } = {}) {
+    if (href.startsWith("#")) return href;
     const rootfile = await this.getRootfile();
-    const from = relativeTo ? this.resolveInternalHref(rootfile, relativeTo) : rootfile;
-    const path = this.resolveInternalHref(from, href);
-    return path.replace(toRoot ? this.adapter.rootPath : (0, import_path.dirname)(rootfile), "").slice(1);
+    const from = relativeTo ? await this.resolveEntry(rootfile, relativeTo) : rootfile;
+    const url = resolveEntryUrl(from, href);
+    if (!url) return href;
+    const entry = (await this.entryForUrl(url)).split("/");
+    const base = toRoot ? [] : rootfile.split("/").slice(0, -1);
+    let shared = 0;
+    while (shared < base.length && base[shared] === entry[shared]) {
+      shared++;
+    }
+    const relative = [
+      ...Array(base.length - shared).fill(".."),
+      ...entry.slice(shared).map(encodeURIComponent)
+    ];
+    return relative.join("/") + url.hash;
   }
   async readFileContents(href, relativeTo, encoding) {
     const rootfile = await this.getRootfile();
-    const from = relativeTo ? this.resolveInternalHref(rootfile, relativeTo) : rootfile;
-    const path = this.resolveInternalHref(from, href);
-    const itemEntry = encoding ? await this.getFileData(path, encoding) : await this.getFileData(path);
+    const from = relativeTo ? await this.resolveEntry(rootfile, relativeTo) : rootfile;
+    const entry = await this.resolveEntry(from, href);
+    const itemEntry = encoding ? await this.adapter.read(entry, encoding) : await this.adapter.read(entry);
     return itemEntry;
   }
   async readItemContents(id, encoding) {
@@ -2095,8 +2191,8 @@ ${JSON.stringify(element, null, 2)}`
     const manifestItem = manifest[id];
     if (!manifestItem)
       throw new Error(`Could not find item with id "${id}" in manifest`);
-    const path = this.resolveInternalHref(rootfile, manifestItem.href);
-    const itemEntry = encoding ? await this.getFileData(path, encoding) : await this.getFileData(path);
+    const entry = await this.resolveEntry(rootfile, manifestItem.href);
+    const itemEntry = encoding ? await this.adapter.read(entry, encoding) : await this.adapter.read(entry);
     return itemEntry;
   }
   /**
@@ -2154,11 +2250,11 @@ ${JSON.stringify(element, null, 2)}`
     if (!manifestItem)
       throw new Error(`Could not find item with id "${id}" in manifest`);
     import_mem.default.clear(this.readXhtmlItemContents);
-    const href = this.resolveInternalHref(rootfile, manifestItem.href);
+    const entry = await this.resolveEntry(rootfile, manifestItem.href);
     if (encoding === "utf-8") {
-      await this.writeEntryContents(href, contents, encoding);
+      await this.writeEntryContents(entry, contents, encoding);
     } else {
-      await this.writeEntryContents(href, contents);
+      await this.writeEntryContents(entry, contents);
     }
   }
   /**
@@ -2229,7 +2325,7 @@ ${JSON.stringify(element, null, 2)}`
     });
     this.manifest = null;
     const rootfile = await this.getRootfile();
-    const filename = this.resolveInternalHref(rootfile, item.href);
+    const filename = await this.resolveEntry(rootfile, item.href);
     const data = encoding === "utf-8" || encoding === "xml" ? new TextEncoder().encode(
       encoding === "utf-8" ? contents : await Epub.xmlBuilder.build(
         contents
@@ -2413,10 +2509,7 @@ ${JSON.stringify(element, null, 2)}`
     );
     const spineTocId = (_a = spine == null ? void 0 : spine[":@"]) == null ? void 0 : _a["@_toc"];
     const ncxItem = spineTocId ? manifest[spineTocId] : Object.values(manifest).find(
-      (item) => {
-        var _a2;
-        return ((_a2 = item.mediaType) == null ? void 0 : _a2.toLowerCase()) === "application/x-dtbncx+xml";
-      }
+      (item) => import_media_types.MediaType.fromMime(item.mediaType ?? "") === import_media_types.MediaType.NCX
     );
     if (!ncxItem) return [];
     const ncxContent = await this.readItemContents(ncxItem.id, "utf-8");
@@ -2557,7 +2650,12 @@ class EpubFactory {
         "This is not a valid EPUB publication. Could not read the package document."
       );
     }
-    await Epub.assertEpub3(epub);
+    try {
+      await Epub.assertEpub3(epub);
+    } catch (error) {
+      epub.discardAndClose();
+      throw error;
+    }
     return epub;
   }
   /**
@@ -2597,14 +2695,11 @@ class EpubFactory {
     const container = encoder.encode(`<?xml version="1.0"?>
 <container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
   <rootfiles>
-    <rootfile media-type="application/oebps-package+xml" full-path="OEBPS/content.opf"/>
+    <rootfile media-type="${import_media_types.MediaType.OPF.mime}" full-path="OEBPS/content.opf"/>
   </rootfiles>
 </container>
 `);
-    await adapter.write(
-      (0, import_path.join)(adapter.rootPath, "META-INF", "container.xml"),
-      container
-    );
+    await adapter.write("META-INF/container.xml", container);
     const packageDocument = encoder.encode(`<?xml version="1.0"?>
 <package unique-identifier="pub-id" dir="${language.textInfo.direction}" xml:lang="${language.toString()}" version="3.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
   <metadata>
@@ -2615,10 +2710,7 @@ class EpubFactory {
   </spine>
 </package>
 `);
-    await adapter.write(
-      (0, import_path.join)(adapter.rootPath, "OEBPS", "content.opf"),
-      packageDocument
-    );
+    await adapter.write("OEBPS/content.opf", packageDocument);
     const epub = new Epub(this.adapterClass, adapter, path);
     const metadata = [
       {
@@ -2667,7 +2759,6 @@ class EpubFactory {
    * @throws when the adapter is read-only
    */
   async upgrade(path, options = {}) {
-    var _a;
     if (!this.adapterClass.capabilities.writable) {
       throw new EpubReadOnlyError(
         `adapter ${this.adapterClass.kind} is read-only; cannot upgrade`
@@ -2693,49 +2784,55 @@ class EpubFactory {
         "This is not a valid EPUB publication. Could not read the package document."
       );
     }
-    const version = await epub.getVersion();
-    if (version.startsWith("3.")) {
-      return epub;
-    }
-    const tocEntries = await epub.getNcxTableOfContents();
-    let landmarks = [];
-    await epub.withPackage((pkg) => {
-      landmarks = Upgrade.extractGuideLandmarks(pkg);
-      Upgrade.upgradePackageMetadata(pkg);
-      Upgrade.fixFontMimeTypes(pkg);
-      Upgrade.removeGuide(pkg);
+    try {
+      const version = await epub.getVersion();
+      if (version.startsWith("3.")) {
+        return epub;
+      }
+      const tocEntries = await epub.getNcxTableOfContents();
+      let landmarks = [];
+      await epub.withPackage((pkg) => {
+        landmarks = Upgrade.extractGuideLandmarks(pkg);
+        Upgrade.upgradePackageMetadata(pkg);
+        Upgrade.fixFontMimeTypes(pkg);
+        Upgrade.removeGuide(pkg);
+        if (removeNcx) {
+          Upgrade.removeSpineTocRef(pkg);
+        }
+        Upgrade.setPackageVersion(pkg, "3.0");
+      });
+      await Upgrade.collectManifestProperties(epub);
       if (removeNcx) {
-        Upgrade.removeSpineTocRef(pkg);
+        await Upgrade.removeNcx(epub);
       }
-      Upgrade.setPackageVersion(pkg, "3.0");
-    });
-    await Upgrade.collectManifestProperties(epub);
-    if (removeNcx) {
-      await Upgrade.removeNcx(epub);
-    }
-    const navHref = await Upgrade.chooseNavHref(epub);
-    const navContent = await Upgrade.buildNavDocument(
-      epub,
-      tocEntries,
-      landmarks
-    );
-    await epub.addManifestItem(
-      {
-        id: "nav",
-        href: navHref,
-        mediaType: "application/xhtml+xml",
-        properties: ["nav"]
-      },
-      navContent,
-      "utf-8"
-    );
-    const manifest = await epub.getManifest();
-    for (const item of Object.values(manifest)) {
-      if (((_a = item.mediaType) == null ? void 0 : _a.toLowerCase()) !== "application/xhtml+xml") continue;
-      const contents = await epub.readXhtmlItemContents(item.id);
-      await epub.writeXhtmlItemContents(item.id, contents);
+      const navHref = await Upgrade.chooseNavHref(epub);
+      const navContent = await Upgrade.buildNavDocument(
+        epub,
+        tocEntries,
+        landmarks
+      );
+      await epub.addManifestItem(
+        {
+          id: "nav",
+          href: navHref,
+          mediaType: import_media_types.MediaType.XHTML.mime,
+          properties: ["nav"]
+        },
+        navContent,
+        "utf-8"
+      );
+      const manifest = await epub.getManifest();
+      for (const item of Object.values(manifest)) {
+        if (import_media_types.MediaType.fromMime(item.mediaType ?? "") !== import_media_types.MediaType.XHTML)
+          continue;
+        const contents = await epub.readXhtmlItemContents(item.id);
+        await epub.writeXhtmlItemContents(item.id, contents);
+      }
+      return epub;
+    } catch (error) {
+      epub.discardAndClose();
+      throw error;
     }
-    return epub;
   }
 }
 // Annotate the CommonJS export names for ESM import in node: