@storyteller-platform/epub 0.7.1 → 0.8.0

package/dist/adapters/interface.d.ts

@@ -7,12 +7,12 @@
  *  - {@link MemoryAdapter} keeps an in-memory zip handle and supports
  *    reads only
  */
-type EpubStorageKind = "tmp-dir" | "in-memory" | (string & {});
-interface EpubStorageCapabilities {
+export type EpubStorageKind = "tmp-dir" | "in-memory" | (string & {});
+export interface EpubStorageCapabilities {
     /** when false, the Epub class refuses every mutation method at runtime */
     readonly writable: boolean;
 }
-interface EpubListEntry {
+export interface EpubListEntry {
     /** location the adapter can read the entry back from, in whatever form it stores */
     absolutePath: string;
     /** the entry name, as it appears in the archive */
@@ -28,7 +28,7 @@ interface EpubListEntry {
  * 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 {
+export interface EpubStorageAdapter {
     read(entry: string): Promise<Uint8Array>;
     read(entry: string, encoding: "utf-8"): Promise<string>;
     /**
@@ -56,7 +56,7 @@ interface EpubStorageAdapter {
     /** Always called on close or error */
     dispose(): void | Promise<void>;
 }
-interface EpubStorageAdapterClass<Opts extends object = object> {
+export interface EpubStorageAdapterClass<Opts extends object = object> {
     readonly kind: EpubStorageKind;
     readonly capabilities: EpubStorageCapabilities;
     /**
@@ -70,6 +70,4 @@ interface EpubStorageAdapterClass<Opts extends object = object> {
      */
     initEmpty?(opts?: Opts): Promise<EpubStorageAdapter>;
 }
-type AdapterOptions<A> = A extends EpubStorageAdapterClass<infer Opts> ? Opts : object;
-
-export type { AdapterOptions, EpubListEntry, EpubStorageAdapter, EpubStorageAdapterClass, EpubStorageCapabilities, EpubStorageKind };
+export type AdapterOptions<A> = A extends EpubStorageAdapterClass<infer Opts> ? Opts : object;

package/dist/adapters/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/memory.d.ts

@@ -1,6 +1,5 @@
-import { EpubStorageAdapter } from './interface.js';
-
-interface MemoryAdapterOptions {
+import type { EpubStorageAdapter } from "./interface.ts";
+export interface MemoryAdapterOptions {
     /**
      * per-entry decompressed buffer cache
      * turn it off when opening many EPUBs and reading each entry at most once
@@ -16,7 +15,7 @@ interface MemoryAdapterOptions {
  * read only
  *
  */
-declare class MemoryAdapter implements EpubStorageAdapter {
+export declare class MemoryAdapter implements EpubStorageAdapter {
     private zip;
     private entries;
     private cache;
@@ -32,5 +31,3 @@ declare class MemoryAdapter implements EpubStorageAdapter {
     archiveLength(entry: string): Promise<number>;
     dispose(): void;
 }
-
-export { MemoryAdapter, type MemoryAdapterOptions };

package/dist/adapters/memory.js

@@ -1,70 +1,75 @@
-import "../chunk-BIEQXUOY.js";
 import { openZip } from "../zip.js";
-class MemoryAdapter {
-  constructor(zip, entries, cache) {
-    this.zip = zip;
-    this.entries = entries;
-    this.cache = cache;
-  }
-  static kind = "in-memory";
-  static capabilities = { writable: false };
-  static async init(source, opts = {}) {
-    const { cache = true, signal } = opts;
-    signal == null ? void 0 : signal.throwIfAborted();
-    const zip = await openZip(source);
-    const entries = /* @__PURE__ */ new Map();
-    try {
-      for await (const entry of zip) {
-        signal == null ? void 0 : signal.throwIfAborted();
-        if (entry.filename.endsWith("/")) continue;
-        entries.set(entry.filename, entry);
-      }
-    } catch (error) {
-      await zip.close();
-      throw error;
+/**
+ * Loads an EPUB archive into memory and serves all I/O off the in-memory zip handle.
+ *
+ * read only
+ *
+ */
+export class MemoryAdapter {
+    zip;
+    entries;
+    cache;
+    static kind = "in-memory";
+    static capabilities = { writable: false };
+    static async init(source, opts = {}) {
+        const { cache = true, signal } = opts;
+        signal?.throwIfAborted();
+        const zip = await openZip(source);
+        const entries = new Map();
+        try {
+            for await (const entry of zip) {
+                signal?.throwIfAborted();
+                if (entry.filename.endsWith("/"))
+                    continue;
+                entries.set(entry.filename, entry);
+            }
+        }
+        catch (error) {
+            await zip.close();
+            throw error;
+        }
+        return new MemoryAdapter(zip, entries, cache ? new Map() : null);
     }
-    return new MemoryAdapter(zip, entries, cache ? /* @__PURE__ */ new Map() : null);
-  }
-  async read(entry, encoding) {
-    var _a, _b;
-    const cached = (_a = this.cache) == null ? void 0 : _a.get(entry);
-    if (cached) {
-      return encoding ? cached.toString(encoding) : new Uint8Array(cached);
+    constructor(zip, entries, cache) {
+        this.zip = zip;
+        this.entries = entries;
+        this.cache = cache;
     }
-    const zipEntry = this.entries.get(entry);
-    if (!zipEntry) {
-      const err = new Error(
-        `ENOENT: zip entry not found in EPUB archive: ${entry}`
-      );
-      err.code = "ENOENT";
-      throw err;
+    async read(entry, encoding) {
+        const cached = this.cache?.get(entry);
+        if (cached) {
+            return encoding ? cached.toString(encoding) : new Uint8Array(cached);
+        }
+        const zipEntry = this.entries.get(entry);
+        if (!zipEntry) {
+            const err = new Error(`ENOENT: zip entry not found in EPUB archive: ${entry}`);
+            err.code = "ENOENT";
+            throw err;
+        }
+        const stream = await zipEntry.openReadStream();
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        const buf = Buffer.concat(chunks);
+        this.cache?.set(entry, buf);
+        return encoding ? buf.toString(encoding) : new Uint8Array(buf);
     }
-    const stream = await zipEntry.openReadStream();
-    const chunks = [];
-    for await (const chunk of stream) {
-      chunks.push(chunk);
+    // eslint-disable-next-line @typescript-eslint/require-await
+    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() {
+        this.entries.clear();
+        this.cache?.clear();
+        // fire-and-forget: closing the handle just releases the fd
+        this.zip.close().catch(() => undefined);
     }
-    const buf = Buffer.concat(chunks);
-    (_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 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;
-    this.entries.clear();
-    (_a = this.cache) == null ? void 0 : _a.clear();
-    this.zip.close().catch(() => void 0);
-  }
 }
-export {
-  MemoryAdapter
-};

package/dist/adapters/tmpfs.d.ts

@@ -1,11 +1,10 @@
-import { EpubStorageAdapter, EpubListEntry } from './interface.js';
-
+import type { EpubListEntry, EpubStorageAdapter } from "./interface.ts";
 /**
  * Extracts an EPUB archive to a temp directory and serves all I/O off
  * the real filesystem.
  * `Epub.using(TmpFsAdapter).from(...)` returns a writable {@link Epub}.
  */
-declare class TmpFsAdapter implements EpubStorageAdapter {
+export declare class TmpFsAdapter implements EpubStorageAdapter {
     private readonly rootPath;
     static readonly kind: "extracted-dir";
     static readonly capabilities: {
@@ -27,5 +26,3 @@ declare class TmpFsAdapter implements EpubStorageAdapter {
     serialize(targetPath: string): Promise<void>;
     dispose(): void;
 }
-
-export { TmpFsAdapter };

package/dist/adapters/tmpfs.js

@@ -1,183 +1,252 @@
-import {
-  __callDispose,
-  __using
-} from "../chunk-BIEQXUOY.js";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { randomUUID } from "node:crypto";
 import { createWriteStream, rmSync } from "node:fs";
-import {
-  cp,
-  mkdir,
-  readFile,
-  readdir,
-  rm,
-  stat,
-  writeFile
-} from "node:fs/promises";
+import { cp, mkdir, readFile, readdir, rm, stat, writeFile, } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
 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";
 import { openZip } from "../zip.js";
-const PRECOMPRESSED_KINDS = /* @__PURE__ */ new Set([
-  "audio",
-  "image",
-  "archive",
-  "package"
+const PRECOMPRESSED_KINDS = new Set([
+    "audio",
+    "image",
+    "archive",
+    "package",
 ]);
 function mintRootPath() {
-  return scratchPath(`storyteller-platform-epub-${randomUUID()}`);
+    return scratchPath(`storyteller-platform-epub-${randomUUID()}`);
 }
+/**
+ * Whether an entry name can be laid down inside the extract root.
+ *
+ * A `.` or `..` segment cannot name a real file, and joining one onto the
+ * root would walk out of it, so such an entry is unreachable here whether it
+ * came from a hostile archive or from an href that spelled it `%2E%2E`.
+ */
 function isStorableEntryName(entry) {
-  return !entry.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
+    return !entry
+        .split("/")
+        .some((segment) => segment === "" || segment === "." || segment === "..");
 }
-class TmpFsAdapter {
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-  }
-  static kind = "extracted-dir";
-  static capabilities = { writable: true };
-  static async init(source) {
-    const rootPath = mintRootPath();
-    try {
-      var _stack = [];
-      try {
-        const zipfile = await openZip(source);
-        const stack = __using(_stack, new AsyncDisposableStack(), true);
-        stack.defer(async () => {
-          await zipfile.close();
-        });
-        for await (const entry of zipfile) {
-          if (entry.filename.endsWith("/")) {
-            continue;
-          }
-          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);
-          await pipeline(readStream, writeStream);
-        }
-      } catch (_) {
-        var _error = _, _hasError = true;
-      } finally {
-        var _promise = __callDispose(_stack, _error, _hasError);
-        _promise && await _promise;
-      }
-    } catch (error) {
-      rmSync(rootPath, { force: true, recursive: true });
-      throw error;
+/**
+ * Extracts an EPUB archive to a temp directory and serves all I/O off
+ * the real filesystem.
+ * `Epub.using(TmpFsAdapter).from(...)` returns a writable {@link Epub}.
+ */
+export class TmpFsAdapter {
+    rootPath;
+    static kind = "extracted-dir";
+    static capabilities = { writable: true };
+    static async init(source) {
+        const rootPath = mintRootPath();
+        try {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const zipfile = await openZip(source);
+                const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+                stack.defer(async () => {
+                    await zipfile.close();
+                });
+                for await (const entry of zipfile) {
+                    if (entry.filename.endsWith("/")) {
+                        // directory entries are skipped; parent dirs are created implicitly
+                        continue;
+                    }
+                    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);
+                    await pipeline(readStream, writeStream);
+                }
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
+        }
+        catch (error) {
+            rmSync(rootPath, { force: true, recursive: true });
+            throw error;
+        }
+        return new TmpFsAdapter(rootPath);
+    }
+    static async initEmpty() {
+        const rootPath = mintRootPath();
+        await mkdir(rootPath, { recursive: true });
+        return new TmpFsAdapter(rootPath);
+    }
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    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("/"));
     }
-    return new TmpFsAdapter(rootPath);
-  }
-  static async initEmpty() {
-    const rootPath = mintRootPath();
-    await mkdir(rootPath, { recursive: true });
-    return new TmpFsAdapter(rootPath);
-  }
-  diskPath(entry) {
-    if (!isStorableEntryName(entry)) {
-      const err = new Error(`ENOENT: no such entry in EPUB archive: ${entry}`);
-      err.code = "ENOENT";
-      throw err;
+    async read(entry, encoding) {
+        return await readFile(this.diskPath(entry), encoding);
     }
-    return join(this.rootPath, ...entry.split("/"));
-  }
-  async read(entry, encoding) {
-    return await readFile(this.diskPath(entry), encoding);
-  }
-  async write(entry, data, encoding) {
-    const path = this.diskPath(entry);
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, data, encoding);
-  }
-  async remove(entry) {
-    await rm(this.diskPath(entry));
-  }
-  async exists(entry) {
-    try {
-      await stat(this.diskPath(entry));
-      return true;
-    } catch {
-      return false;
+    async write(entry, data, encoding) {
+        const path = this.diskPath(entry);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, data, encoding);
     }
-  }
-  async archiveLength(entry) {
-    try {
-      const st = await stat(this.diskPath(entry));
-      return st.size;
-    } catch {
-      return 0;
+    async remove(entry) {
+        await rm(this.diskPath(entry));
     }
-  }
-  async *list() {
-    const entries = await readdir(this.rootPath, {
-      recursive: true,
-      withFileTypes: true
-    });
-    for (const entry of entries) {
-      if (entry.isDirectory()) continue;
-      const absolutePath = join(entry.parentPath, entry.name);
-      yield {
-        absolutePath,
-        relativePath: absolutePath.slice(this.rootPath.length + 1).split(sep).join("/")
-      };
+    async exists(entry) {
+        try {
+            await stat(this.diskPath(entry));
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-  }
-  async duplicate() {
-    const newRoot = mintRootPath();
-    try {
-      await cp(this.rootPath, newRoot, { recursive: true });
-    } catch (error) {
-      rmSync(newRoot, { force: true, recursive: true });
-      throw error;
+    async archiveLength(entry) {
+        try {
+            const st = await stat(this.diskPath(entry));
+            return st.size;
+        }
+        catch {
+            return 0;
+        }
     }
-    return new TmpFsAdapter(newRoot);
-  }
-  async serialize(targetPath) {
-    var _a;
-    var _stack = [];
-    try {
-      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(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: !PRECOMPRESSED_KINDS.has(
-            (_a = MediaType.fromPath(entry.absolutePath)) == null ? void 0 : _a.kind
-          )
+    async *list() {
+        const entries = await readdir(this.rootPath, {
+            recursive: true,
+            withFileTypes: true,
         });
-      }
-      zipfile.end();
-      await promise;
-      await cp(tmpArchivePath, targetPath);
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      var _promise = __callDispose(_stack, _error, _hasError);
-      _promise && await _promise;
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                continue;
+            const absolutePath = join(entry.parentPath, entry.name);
+            yield {
+                absolutePath,
+                relativePath: absolutePath
+                    .slice(this.rootPath.length + 1)
+                    .split(sep)
+                    .join("/"),
+            };
+        }
+    }
+    async duplicate() {
+        const newRoot = mintRootPath();
+        try {
+            await cp(this.rootPath, newRoot, { recursive: true });
+        }
+        catch (error) {
+            rmSync(newRoot, { force: true, recursive: true });
+            throw error;
+        }
+        return new TmpFsAdapter(newRoot);
+    }
+    async serialize(targetPath) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tmpArchivePath = mintRootPath();
+            // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+            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 = __addDisposableResource(env_2, new AsyncDisposableStack(), true);
+            stack.defer(async () => {
+                writeStream.close();
+                await rm(tmpArchivePath, { force: true });
+            });
+            zipfile.outputStream.pipe(writeStream);
+            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: !PRECOMPRESSED_KINDS.has(MediaType.fromPath(entry.absolutePath)?.kind),
+                });
+            }
+            zipfile.end();
+            await promise;
+            await cp(tmpArchivePath, targetPath);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    dispose() {
+        rmSync(this.rootPath, { recursive: true, force: true });
     }
-  }
-  dispose() {
-    rmSync(this.rootPath, { recursive: true, force: true });
-  }
 }
-export {
-  TmpFsAdapter
-};

package/dist/epubcheck.d.ts

@@ -1,4 +1,4 @@
-interface Location {
+export interface Location {
     url: {
         hierachical: boolean;
         opaque: boolean;
@@ -8,16 +8,14 @@ interface Location {
     column: number;
     context: string | null;
 }
-interface Message {
+export interface Message {
     ID: string;
     severity: "FATAL" | "ERROR" | "WARNING" | "INFO" | "USAGE";
     message: string;
     additionalLocations: number;
     locations: Location[];
 }
-interface Report {
+export interface Report {
     messages: Message[];
 }
-declare function epubcheck(epubFile: string): Promise<Report>;
-
-export { type Location, type Message, type Report, epubcheck };
+export declare function epubcheck(epubFile: string): Promise<Report>;