@storyteller-platform/epub 0.7.0 → 0.7.1

package/dist/adapters/interface.d.cts

@@ -13,30 +13,40 @@ interface EpubStorageCapabilities {
     readonly writable: boolean;
 }
 interface EpubListEntry {
-    /** absolute path under {@link EpubStorageAdapter.rootPath} */
+    /** location the adapter can read the entry back from, in whatever form it stores */
     absolutePath: string;
-    /** path relative to {@link EpubStorageAdapter.rootPath}, slash-separated */
+    /** the entry name, as it appears in the archive */
     relativePath: string;
 }
+/**
+ * Adapters only receive entry names, which is:
+ * - the name a file has in the archive itself
+ * - relative to the container root, slash-separated,
+ * - already percent-decoded (eg `OEBPS/a b.xhtml`, not `OEBPS/a%20b.xhtml`)
+ *
+ * Adapter decides where to store files under what name
+ * In previous versions of the EPUB lib, this was a little bit more muddled, leading to
+ * eg the TmpFsAdapter trying to read `OEBPS/a%20b.xhtml`, whereas it was stored as `OEBPS/a b.xhtml`
+ */
 interface EpubStorageAdapter {
+    read(entry: string): Promise<Uint8Array>;
+    read(entry: string, encoding: "utf-8"): Promise<string>;
     /**
-     * Opaque path prefix used by `resolveInternalHref` to anchor absolute
-     * paths within the archive. For TmpFsAdapter this is the tmp dir;
-     * for MemoryAdapter it's a virtual prefix that's never written to disk
+     * Whether the archive holds an entry under exactly this name.
+     * Used to choose between different canditates for an href
+     * so should be exact
      */
-    readonly rootPath: string;
-    read(path: string): Promise<Uint8Array>;
-    read(path: string, encoding: "utf-8"): Promise<string>;
+    exists(entry: string): Promise<boolean>;
     /**
      * Length of an entry in bytes, for the readium page-count heuristic
      * which expects compressed size when available
      */
-    archiveLength(path: string): Promise<number>;
+    archiveLength(entry: string): Promise<number>;
     /** Required for any mutation method on Epub */
-    write?(path: string, data: Uint8Array): Promise<void>;
-    write?(path: string, data: string, encoding: "utf-8"): Promise<void>;
+    write?(entry: string, data: Uint8Array): Promise<void>;
+    write?(entry: string, data: string, encoding: "utf-8"): Promise<void>;
     /** Required for removeManifestItem / setCoverImage replacement */
-    remove?(path: string): Promise<void>;
+    remove?(entry: string): Promise<void>;
     /** Required for Epub.saveAndClose to walk the contents */
     list?(): AsyncIterable<EpubListEntry>;
     /** Required for Epub.copy */
@@ -50,17 +60,13 @@ interface EpubStorageAdapterClass<Opts extends object = object> {
     readonly kind: EpubStorageKind;
     readonly capabilities: EpubStorageCapabilities;
     /**
-     * Open an archive from a path or buffer. The returned adapter is
-     * ready to read; the Epub class will assert it's a valid EPUB 3
-     * afterwards.
+     * Open an archive from a path or buffer.
+     * Will throw if the archive is not a valid EPUB 3
      */
     init(source: string | Uint8Array, opts?: Opts): Promise<EpubStorageAdapter>;
     /**
      * Initialize an empty extract root for {@link Epub.create}.
-     *
-     * Optional — adapters that can't be written to from scratch
-     * (e.g. read-only zip handles) should leave this off, and
-     * `Epub.using(...).create(...)` will throw.
+     * Only necessary for adapters that can write
      */
     initEmpty?(opts?: Opts): Promise<EpubStorageAdapter>;
 }

package/dist/adapters/interface.d.ts

@@ -13,30 +13,40 @@ interface EpubStorageCapabilities {
     readonly writable: boolean;
 }
 interface EpubListEntry {
-    /** absolute path under {@link EpubStorageAdapter.rootPath} */
+    /** location the adapter can read the entry back from, in whatever form it stores */
     absolutePath: string;
-    /** path relative to {@link EpubStorageAdapter.rootPath}, slash-separated */
+    /** the entry name, as it appears in the archive */
     relativePath: string;
 }
+/**
+ * Adapters only receive entry names, which is:
+ * - the name a file has in the archive itself
+ * - relative to the container root, slash-separated,
+ * - already percent-decoded (eg `OEBPS/a b.xhtml`, not `OEBPS/a%20b.xhtml`)
+ *
+ * Adapter decides where to store files under what name
+ * In previous versions of the EPUB lib, this was a little bit more muddled, leading to
+ * eg the TmpFsAdapter trying to read `OEBPS/a%20b.xhtml`, whereas it was stored as `OEBPS/a b.xhtml`
+ */
 interface EpubStorageAdapter {
+    read(entry: string): Promise<Uint8Array>;
+    read(entry: string, encoding: "utf-8"): Promise<string>;
     /**
-     * Opaque path prefix used by `resolveInternalHref` to anchor absolute
-     * paths within the archive. For TmpFsAdapter this is the tmp dir;
-     * for MemoryAdapter it's a virtual prefix that's never written to disk
+     * Whether the archive holds an entry under exactly this name.
+     * Used to choose between different canditates for an href
+     * so should be exact
      */
-    readonly rootPath: string;
-    read(path: string): Promise<Uint8Array>;
-    read(path: string, encoding: "utf-8"): Promise<string>;
+    exists(entry: string): Promise<boolean>;
     /**
      * Length of an entry in bytes, for the readium page-count heuristic
      * which expects compressed size when available
      */
-    archiveLength(path: string): Promise<number>;
+    archiveLength(entry: string): Promise<number>;
     /** Required for any mutation method on Epub */
-    write?(path: string, data: Uint8Array): Promise<void>;
-    write?(path: string, data: string, encoding: "utf-8"): Promise<void>;
+    write?(entry: string, data: Uint8Array): Promise<void>;
+    write?(entry: string, data: string, encoding: "utf-8"): Promise<void>;
     /** Required for removeManifestItem / setCoverImage replacement */
-    remove?(path: string): Promise<void>;
+    remove?(entry: string): Promise<void>;
     /** Required for Epub.saveAndClose to walk the contents */
     list?(): AsyncIterable<EpubListEntry>;
     /** Required for Epub.copy */
@@ -50,17 +60,13 @@ interface EpubStorageAdapterClass<Opts extends object = object> {
     readonly kind: EpubStorageKind;
     readonly capabilities: EpubStorageCapabilities;
     /**
-     * Open an archive from a path or buffer. The returned adapter is
-     * ready to read; the Epub class will assert it's a valid EPUB 3
-     * afterwards.
+     * Open an archive from a path or buffer.
+     * Will throw if the archive is not a valid EPUB 3
      */
     init(source: string | Uint8Array, opts?: Opts): Promise<EpubStorageAdapter>;
     /**
      * Initialize an empty extract root for {@link Epub.create}.
-     *
-     * Optional — adapters that can't be written to from scratch
-     * (e.g. read-only zip handles) should leave this off, and
-     * `Epub.using(...).create(...)` will throw.
+     * Only necessary for adapters that can write
      */
     initEmpty?(opts?: Opts): Promise<EpubStorageAdapter>;
 }

package/dist/adapters/memory.cjs

@@ -21,13 +21,9 @@ __export(memory_exports, {
   MemoryAdapter: () => MemoryAdapter
 });
 module.exports = __toCommonJS(memory_exports);
-var import_node_crypto = require("node:crypto");
-var import_node_os = require("node:os");
-var import_yauzl_promise = require("yauzl-promise");
-var import_path = require("@storyteller-platform/path");
+var import_zip = require("../zip.cjs");
 class MemoryAdapter {
-  constructor(rootPath, zip, entries, cache) {
-    this.rootPath = rootPath;
+  constructor(zip, entries, cache) {
     this.zip = zip;
     this.entries = entries;
     this.cache = cache;
@@ -37,7 +33,7 @@ class MemoryAdapter {
   static async init(source, opts = {}) {
     const { cache = true, signal } = opts;
     signal == null ? void 0 : signal.throwIfAborted();
-    const zip = typeof source === "string" ? await (0, import_yauzl_promise.open)(source) : await (0, import_yauzl_promise.fromBuffer)(Buffer.from(source));
+    const zip = await (0, import_zip.openZip)(source);
     const entries = /* @__PURE__ */ new Map();
     try {
       for await (const entry of zip) {
@@ -49,46 +45,40 @@ class MemoryAdapter {
       await zip.close();
       throw error;
     }
-    const rootPath = (0, import_path.join)(
-      (0, import_node_os.tmpdir)(),
-      `storyteller-platform-epub-zip-${(0, import_node_crypto.randomUUID)()}.epub`
-    );
-    return new MemoryAdapter(rootPath, zip, entries, cache ? /* @__PURE__ */ new Map() : null);
+    return new MemoryAdapter(zip, entries, cache ? /* @__PURE__ */ new Map() : null);
   }
-  toZipEntryKey(path) {
-    const prefix = this.rootPath.endsWith(import_path.sep) ? this.rootPath : this.rootPath + import_path.sep;
-    const rel = path.startsWith(prefix) ? path.slice(prefix.length) : path;
-    return import_path.sep === "/" ? rel : rel.split(import_path.sep).join("/");
-  }
-  async read(path, encoding) {
+  async read(entry, encoding) {
     var _a, _b;
-    const key = this.toZipEntryKey(path);
-    const cached = (_a = this.cache) == null ? void 0 : _a.get(key);
+    const cached = (_a = this.cache) == null ? void 0 : _a.get(entry);
     if (cached) {
       return encoding ? cached.toString(encoding) : new Uint8Array(cached);
     }
-    const entry = this.entries.get(key);
-    if (!entry) {
+    const zipEntry = this.entries.get(entry);
+    if (!zipEntry) {
       const err = new Error(
-        `ENOENT: zip entry not found in EPUB archive: ${key}`
+        `ENOENT: zip entry not found in EPUB archive: ${entry}`
       );
       err.code = "ENOENT";
       throw err;
     }
-    const stream = await entry.openReadStream();
+    const stream = await zipEntry.openReadStream();
     const chunks = [];
     for await (const chunk of stream) {
       chunks.push(chunk);
     }
     const buf = Buffer.concat(chunks);
-    (_b = this.cache) == null ? void 0 : _b.set(key, buf);
+    (_b = this.cache) == null ? void 0 : _b.set(entry, buf);
     return encoding ? buf.toString(encoding) : new Uint8Array(buf);
   }
   // eslint-disable-next-line @typescript-eslint/require-await
-  async archiveLength(path) {
-    const entry = this.entries.get(this.toZipEntryKey(path));
-    if (!entry) return 0;
-    return entry.compressedSize || entry.uncompressedSize;
+  async exists(entry) {
+    return this.entries.has(entry);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async archiveLength(entry) {
+    const zipEntry = this.entries.get(entry);
+    if (!zipEntry) return 0;
+    return zipEntry.compressedSize || zipEntry.uncompressedSize;
   }
   dispose() {
     var _a;

package/dist/adapters/memory.d.cts

@@ -17,7 +17,6 @@ interface MemoryAdapterOptions {
  *
  */
 declare class MemoryAdapter implements EpubStorageAdapter {
-    readonly rootPath: string;
     private zip;
     private entries;
     private cache;
@@ -27,10 +26,10 @@ declare class MemoryAdapter implements EpubStorageAdapter {
     };
     static init(source: string | Uint8Array, opts?: MemoryAdapterOptions): Promise<MemoryAdapter>;
     private constructor();
-    private toZipEntryKey;
-    read(path: string): Promise<Uint8Array>;
-    read(path: string, encoding: "utf-8"): Promise<string>;
-    archiveLength(path: string): Promise<number>;
+    read(entry: string): Promise<Uint8Array>;
+    read(entry: string, encoding: "utf-8"): Promise<string>;
+    exists(entry: string): Promise<boolean>;
+    archiveLength(entry: string): Promise<number>;
     dispose(): void;
 }
 

package/dist/adapters/memory.d.ts

@@ -17,7 +17,6 @@ interface MemoryAdapterOptions {
  *
  */
 declare class MemoryAdapter implements EpubStorageAdapter {
-    readonly rootPath: string;
     private zip;
     private entries;
     private cache;
@@ -27,10 +26,10 @@ declare class MemoryAdapter implements EpubStorageAdapter {
     };
     static init(source: string | Uint8Array, opts?: MemoryAdapterOptions): Promise<MemoryAdapter>;
     private constructor();
-    private toZipEntryKey;
-    read(path: string): Promise<Uint8Array>;
-    read(path: string, encoding: "utf-8"): Promise<string>;
-    archiveLength(path: string): Promise<number>;
+    read(entry: string): Promise<Uint8Array>;
+    read(entry: string, encoding: "utf-8"): Promise<string>;
+    exists(entry: string): Promise<boolean>;
+    archiveLength(entry: string): Promise<number>;
     dispose(): void;
 }
 

package/dist/adapters/memory.js

@@ -1,14 +1,7 @@
 import "../chunk-BIEQXUOY.js";
-import { randomUUID } from "node:crypto";
-import { tmpdir } from "node:os";
-import {
-  fromBuffer,
-  open
-} from "yauzl-promise";
-import { join, sep } from "@storyteller-platform/path";
+import { openZip } from "../zip.js";
 class MemoryAdapter {
-  constructor(rootPath, zip, entries, cache) {
-    this.rootPath = rootPath;
+  constructor(zip, entries, cache) {
     this.zip = zip;
     this.entries = entries;
     this.cache = cache;
@@ -18,7 +11,7 @@ class MemoryAdapter {
   static async init(source, opts = {}) {
     const { cache = true, signal } = opts;
     signal == null ? void 0 : signal.throwIfAborted();
-    const zip = typeof source === "string" ? await open(source) : await fromBuffer(Buffer.from(source));
+    const zip = await openZip(source);
     const entries = /* @__PURE__ */ new Map();
     try {
       for await (const entry of zip) {
@@ -30,46 +23,40 @@ class MemoryAdapter {
       await zip.close();
       throw error;
     }
-    const rootPath = join(
-      tmpdir(),
-      `storyteller-platform-epub-zip-${randomUUID()}.epub`
-    );
-    return new MemoryAdapter(rootPath, zip, entries, cache ? /* @__PURE__ */ new Map() : null);
+    return new MemoryAdapter(zip, entries, cache ? /* @__PURE__ */ new Map() : null);
   }
-  toZipEntryKey(path) {
-    const prefix = this.rootPath.endsWith(sep) ? this.rootPath : this.rootPath + sep;
-    const rel = path.startsWith(prefix) ? path.slice(prefix.length) : path;
-    return sep === "/" ? rel : rel.split(sep).join("/");
-  }
-  async read(path, encoding) {
+  async read(entry, encoding) {
     var _a, _b;
-    const key = this.toZipEntryKey(path);
-    const cached = (_a = this.cache) == null ? void 0 : _a.get(key);
+    const cached = (_a = this.cache) == null ? void 0 : _a.get(entry);
     if (cached) {
       return encoding ? cached.toString(encoding) : new Uint8Array(cached);
     }
-    const entry = this.entries.get(key);
-    if (!entry) {
+    const zipEntry = this.entries.get(entry);
+    if (!zipEntry) {
       const err = new Error(
-        `ENOENT: zip entry not found in EPUB archive: ${key}`
+        `ENOENT: zip entry not found in EPUB archive: ${entry}`
       );
       err.code = "ENOENT";
       throw err;
     }
-    const stream = await entry.openReadStream();
+    const stream = await zipEntry.openReadStream();
     const chunks = [];
     for await (const chunk of stream) {
       chunks.push(chunk);
     }
     const buf = Buffer.concat(chunks);
-    (_b = this.cache) == null ? void 0 : _b.set(key, buf);
+    (_b = this.cache) == null ? void 0 : _b.set(entry, buf);
     return encoding ? buf.toString(encoding) : new Uint8Array(buf);
   }
   // eslint-disable-next-line @typescript-eslint/require-await
-  async archiveLength(path) {
-    const entry = this.entries.get(this.toZipEntryKey(path));
-    if (!entry) return 0;
-    return entry.compressedSize || entry.uncompressedSize;
+  async exists(entry) {
+    return this.entries.has(entry);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async archiveLength(entry) {
+    const zipEntry = this.entries.get(entry);
+    if (!zipEntry) return 0;
+    return zipEntry.compressedSize || zipEntry.uncompressedSize;
   }
   dispose() {
     var _a;

package/dist/adapters/tmpfs.cjs

@@ -69,39 +69,23 @@ module.exports = __toCommonJS(tmpfs_exports);
 var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
 var import_promises = require("node:fs/promises");
-var import_node_os = require("node:os");
 var import_promises2 = require("node:stream/promises");
-var import_yauzl_promise = require("yauzl-promise");
 var import_yazl = require("yazl");
+var import_fs = require("@storyteller-platform/fs");
+var import_media_types = require("@storyteller-platform/media-types");
 var import_path = require("@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));
-}
+var import_zip = require("../zip.cjs");
+const PRECOMPRESSED_KINDS = /* @__PURE__ */ new Set([
+  "audio",
+  "image",
+  "archive",
+  "package"
+]);
 function mintRootPath() {
-  return (0, import_path.join)((0, import_node_os.tmpdir)(), `storyteller-platform-epub-${(0, import_node_crypto.randomUUID)()}`);
+  return (0, import_fs.scratchPath)(`storyteller-platform-epub-${(0, import_node_crypto.randomUUID)()}`);
+}
+function isStorableEntryName(entry) {
+  return !entry.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
 }
 class TmpFsAdapter {
   constructor(rootPath) {
@@ -114,7 +98,7 @@ class TmpFsAdapter {
     try {
       var _stack = [];
       try {
-        const zipfile = typeof source === "string" ? await (0, import_yauzl_promise.open)(source) : await (0, import_yauzl_promise.fromBuffer)(Buffer.from(source));
+        const zipfile = await (0, import_zip.openZip)(source);
         const stack = __using(_stack, new AsyncDisposableStack(), true);
         stack.defer(async () => {
           await zipfile.close();
@@ -123,7 +107,8 @@ class TmpFsAdapter {
           if (entry.filename.endsWith("/")) {
             continue;
           }
-          const writePath = (0, import_path.join)(rootPath, entry.filename);
+          if (!isStorableEntryName(entry.filename)) continue;
+          const writePath = (0, import_path.join)(rootPath, ...entry.filename.split("/"));
           const readStream = await entry.openReadStream();
           await (0, import_promises.mkdir)((0, import_path.dirname)(writePath), { recursive: true });
           const writeStream = (0, import_node_fs.createWriteStream)(writePath);
@@ -146,19 +131,36 @@ class TmpFsAdapter {
     await (0, import_promises.mkdir)(rootPath, { recursive: true });
     return new TmpFsAdapter(rootPath);
   }
-  async read(path, encoding) {
-    return await (0, import_promises.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 (0, import_path.join)(this.rootPath, ...entry.split("/"));
+  }
+  async read(entry, encoding) {
+    return await (0, import_promises.readFile)(this.diskPath(entry), encoding);
   }
-  async write(path, data, encoding) {
+  async write(entry, data, encoding) {
+    const path = this.diskPath(entry);
     await (0, import_promises.mkdir)((0, import_path.dirname)(path), { recursive: true });
     await (0, import_promises.writeFile)(path, data, encoding);
   }
-  async remove(path) {
-    await (0, import_promises.rm)(path);
+  async remove(entry) {
+    await (0, import_promises.rm)(this.diskPath(entry));
+  }
+  async exists(entry) {
+    try {
+      await (0, import_promises.stat)(this.diskPath(entry));
+      return true;
+    } catch {
+      return false;
+    }
   }
-  async archiveLength(path) {
+  async archiveLength(entry) {
     try {
-      const st = await (0, import_promises.stat)(path);
+      const st = await (0, import_promises.stat)(this.diskPath(entry));
       return st.size;
     } catch {
       return 0;
@@ -174,7 +176,7 @@ class TmpFsAdapter {
       const absolutePath = (0, import_path.join)(entry.parentPath, entry.name);
       yield {
         absolutePath,
-        relativePath: absolutePath.replace(`${this.rootPath}${import_path.sep}`, "")
+        relativePath: absolutePath.slice(this.rootPath.length + 1).split(import_path.sep).join("/")
       };
     }
   }
@@ -189,31 +191,33 @@ class TmpFsAdapter {
     return new TmpFsAdapter(newRoot);
   }
   async serialize(targetPath) {
+    var _a;
     var _stack = [];
     try {
-      const tmpArchivePath = (0, import_path.join)(
-        (0, import_node_os.tmpdir)(),
-        `storyteller-platform-epub-${(0, import_node_crypto.randomUUID)()}`
-      );
-      const { promise, resolve } = Promise.withResolvers();
+      const tmpArchivePath = mintRootPath();
+      const { promise, resolve, reject } = Promise.withResolvers();
       const zipfile = new import_yazl.ZipFile();
       const writeStream = (0, import_node_fs.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 (0, import_promises.rm)(tmpArchivePath, { force: true });
       });
       zipfile.outputStream.pipe(writeStream);
-      zipfile.addBuffer(Buffer.from("application/epub+zip"), "mimetype", {
+      zipfile.addBuffer(Buffer.from(import_media_types.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 = import_media_types.MediaType.fromPath(entry.absolutePath)) == null ? void 0 : _a.kind
+          )
         });
       }
       zipfile.end();

package/dist/adapters/tmpfs.d.cts

@@ -6,7 +6,7 @@ import { EpubStorageAdapter, EpubListEntry } from './interface.cjs';
  * `Epub.using(TmpFsAdapter).from(...)` returns a writable {@link Epub}.
  */
 declare class TmpFsAdapter implements EpubStorageAdapter {
-    readonly rootPath: string;
+    private readonly rootPath;
     static readonly kind: "extracted-dir";
     static readonly capabilities: {
         readonly writable: true;
@@ -14,12 +14,14 @@ declare class TmpFsAdapter implements EpubStorageAdapter {
     static init(source: string | Uint8Array): Promise<TmpFsAdapter>;
     static initEmpty(): Promise<TmpFsAdapter>;
     private constructor();
-    read(path: string): Promise<Uint8Array>;
-    read(path: string, encoding: "utf-8"): Promise<string>;
-    write(path: string, data: Uint8Array): Promise<void>;
-    write(path: string, data: string, encoding: "utf-8"): Promise<void>;
-    remove(path: string): Promise<void>;
-    archiveLength(path: string): Promise<number>;
+    private diskPath;
+    read(entry: string): Promise<Uint8Array>;
+    read(entry: string, encoding: "utf-8"): Promise<string>;
+    write(entry: string, data: Uint8Array): Promise<void>;
+    write(entry: string, data: string, encoding: "utf-8"): Promise<void>;
+    remove(entry: string): Promise<void>;
+    exists(entry: string): Promise<boolean>;
+    archiveLength(entry: string): Promise<number>;
     list(): AsyncIterable<EpubListEntry>;
     duplicate(): Promise<TmpFsAdapter>;
     serialize(targetPath: string): Promise<void>;

package/dist/adapters/tmpfs.d.ts

@@ -6,7 +6,7 @@ import { EpubStorageAdapter, EpubListEntry } from './interface.js';
  * `Epub.using(TmpFsAdapter).from(...)` returns a writable {@link Epub}.
  */
 declare class TmpFsAdapter implements EpubStorageAdapter {
-    readonly rootPath: string;
+    private readonly rootPath;
     static readonly kind: "extracted-dir";
     static readonly capabilities: {
         readonly writable: true;
@@ -14,12 +14,14 @@ declare class TmpFsAdapter implements EpubStorageAdapter {
     static init(source: string | Uint8Array): Promise<TmpFsAdapter>;
     static initEmpty(): Promise<TmpFsAdapter>;
     private constructor();
-    read(path: string): Promise<Uint8Array>;
-    read(path: string, encoding: "utf-8"): Promise<string>;
-    write(path: string, data: Uint8Array): Promise<void>;
-    write(path: string, data: string, encoding: "utf-8"): Promise<void>;
-    remove(path: string): Promise<void>;
-    archiveLength(path: string): Promise<number>;
+    private diskPath;
+    read(entry: string): Promise<Uint8Array>;
+    read(entry: string, encoding: "utf-8"): Promise<string>;
+    write(entry: string, data: Uint8Array): Promise<void>;
+    write(entry: string, data: string, encoding: "utf-8"): Promise<void>;
+    remove(entry: string): Promise<void>;
+    exists(entry: string): Promise<boolean>;
+    archiveLength(entry: string): Promise<number>;
     list(): AsyncIterable<EpubListEntry>;
     duplicate(): Promise<TmpFsAdapter>;
     serialize(targetPath: string): Promise<void>;