@storyteller-platform/epub 0.8.1 → 1.0.0

package/dist/xml.js

@@ -0,0 +1,248 @@
+import xmldom from "@xmldom/xmldom";
+const { DOMParser } = xmldom;
+export const { XMLSerializer } = xmldom;
+export function isElement(n) {
+    return n.nodeType === 1;
+}
+export function isText(n) {
+    return n.nodeType === 3;
+}
+export function isCdata(n) {
+    return n.nodeType === 4;
+}
+export function isComment(n) {
+    return n.nodeType === 8;
+}
+function setNamespace(element, namespace) {
+    ;
+    element.namespaceURI = namespace;
+}
+/**
+ * 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 function adoptNamespaces(node) {
+    const { parentNode } = node;
+    const inherited = parentNode && isElement(parentNode) ? parentNode.namespaceURI : null;
+    if (inherited && !node.namespaceURI) {
+        setNamespace(node, inherited);
+    }
+    for (const child of Array.from(node.children)) {
+        adoptNamespaces(child);
+    }
+}
+/**
+ * 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 function declareDefaultNamespace(element, uri) {
+    element.setAttributeNS(NS.xmlns, "xmlns", uri);
+    setNamespace(element, uri);
+    adoptNamespaces(element);
+}
+/**
+ * Insert `child` into `parent`, then adopt its namespace.
+ *
+ * If `reference` is omitted, appends child to parent.
+ */
+export function insert(parent, child, reference) {
+    parent.insertBefore(child, reference ?? null);
+    if (isElement(child))
+        adoptNamespaces(child);
+    return child;
+}
+/**
+ * Replace `oldChild` with `newChild` in `parent`, then adopt the new child's
+ * namespace.
+ */
+export function replace(parent, newChild, oldChild) {
+    parent.replaceChild(newChild, oldChild);
+    if (isElement(newChild))
+        adoptNamespaces(newChild);
+    return newChild;
+}
+/**
+ * Given an XHTML document, return the body element.
+ */
+export function getXhtmlBody(document) {
+    const html = document.documentElement;
+    if (!html)
+        throw new Error("Invalid XHTML document: no html element");
+    const body = html.getElementsByTagName("body").item(0);
+    if (!body)
+        throw new Error("Invalid XHTML document: No body element");
+    return body;
+}
+/**
+ * Given an Element, find the first child matching
+ * the provided namespace, name and optional filter.
+ */
+export function findXmlChildByNameNS(namespaceUri, name, element, filter) {
+    for (const child of Array.from(element.children)) {
+        if ((!namespaceUri || namespaceUri === child.namespaceURI) &&
+            name === child.localName &&
+            (!filter || filter(child))) {
+            return child;
+        }
+    }
+    return undefined;
+}
+/**
+ * Given an Element, find the first child matching
+ * the provided name and optional filter.
+ */
+export function findXmlChildByName(name, element, filter) {
+    return findXmlChildByNameNS(null, name, element, filter);
+}
+/**
+ * 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 function findXmlDescendantByNameNS(namespaceUri, name, element, filter) {
+    const queue = Array.from(element.children);
+    while (queue.length > 0) {
+        const candidate = queue.shift();
+        if (!candidate)
+            continue;
+        if ((!namespaceUri || candidate.namespaceURI === namespaceUri) &&
+            candidate.localName === name &&
+            (!filter || filter(candidate))) {
+            return candidate;
+        }
+        queue.push(...Array.from(candidate.children));
+    }
+    return 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 function findXmlDescendantByName(name, element, filter) {
+    return findXmlDescendantByNameNS(null, name, element, filter);
+}
+/**
+ * Given an XHTML document, add a `link` element to the
+ * `head` of the document.
+ */
+export function addLinkToXhtmlHead(document, link) {
+    const html = document.documentElement;
+    if (!html)
+        throw new Error("Invalid XHTML document: no html element");
+    const head = html.getElementsByTagName("head").item(0);
+    if (!head)
+        throw new Error("Invalid XHTML document: no head element");
+    const linkEl = document.createElement("link");
+    linkEl.setAttribute("rel", link.rel);
+    linkEl.setAttribute("href", link.href);
+    linkEl.setAttribute("type", link.type);
+    head.appendChild(linkEl);
+}
+export function parse(xml, mediaType, onError) {
+    // A byte order mark ahead of the XML declaration is legal in a file, but once
+    // the file has been decoded into a string the mark occupies offset 0, and
+    // xmldom then rejects the declaration for not being at the start.
+    const source = xml.charCodeAt(0) === 0xfeff ? xml.slice(1) : xml;
+    return new DOMParser({
+        onError: (level, message) => {
+            onError?.({
+                level,
+                message,
+            });
+        },
+    }).parseFromString(source, mediaType);
+}
+export function serialize(doc, options) {
+    const serialized = new XMLSerializer().serializeToString(doc);
+    if (options?.validate) {
+        new DOMParser({
+            onError: (level, message) => {
+                if (level === "error" || level === "fatalError") {
+                    throw new Error(message);
+                }
+            },
+        }).parseFromString(serialized, "text/xml");
+    }
+    return serialized;
+}
+const xmlDoc = new DOMParser({ onError: () => { } }).parseFromString("<root/>", "text/xml");
+export const NS = {
+    xmlns: "http://www.w3.org/2000/xmlns/",
+    xml: "http://www.w3.org/XML/1998/namespace",
+    xhtml: "http://www.w3.org/1999/xhtml",
+    opf: "http://www.idpf.org/2007/opf",
+    dc: "http://purl.org/dc/elements/1.1/",
+    epub: "http://www.idpf.org/2007/ops",
+};
+const nsPrefixes = Object.keys(NS);
+export function x(name, attributes, ...children) {
+    if (name === "xmlns" || name.startsWith("xmlns:")) {
+        throw new Error(`Invalid element name ${name}`);
+    }
+    const nameNs = nsPrefixes.find((prefix) => name.startsWith(`${prefix}:`));
+    const element = nameNs
+        ? xmlDoc.createElementNS(NS[nameNs], name)
+        : xmlDoc.createElement(name);
+    for (const [attrName, value] of Object.entries(attributes ?? {})) {
+        if (value === undefined)
+            continue;
+        const attrNs = attrName === "xmlns"
+            ? "xmlns"
+            : nsPrefixes.find((prefix) => attrName.startsWith(`${prefix}:`));
+        if (attrNs) {
+            element.setAttributeNS(NS[attrNs], attrName, value);
+        }
+        else {
+            element.setAttribute(attrName, value);
+        }
+    }
+    // An `xmlns` attribute declares this element's own default namespace, but
+    // xmldom does not bind it the way the DOM requires. Without this the element
+    // reports `namespaceURI === null`, so `adoptNamespaces` re-declares over the
+    // top of it: the output carries two `xmlns` attributes, which fails to parse
+    // (`Attribute xmlns redefined`), and the element lands in the wrong namespace.
+    const defaultNamespace = (attributes ?? {})["xmlns"];
+    if (defaultNamespace !== undefined) {
+        setNamespace(element, defaultNamespace);
+    }
+    for (const child of children) {
+        if (child == null)
+            continue;
+        if (typeof child === "string") {
+            element.appendChild(xmlDoc.createTextNode(child));
+        }
+        else {
+            element.appendChild(child);
+        }
+    }
+    return element;
+}
+export function text(data) {
+    return xmlDoc.createTextNode(data);
+}
+export function createDocument(namespaceUri, qualifiedName, docType) {
+    return xmlDoc.implementation.createDocument(namespaceUri, qualifiedName, docType);
+}
+export function createDocumentType(qualifiedName, publicId, systemId) {
+    return xmlDoc.implementation.createDocumentType(qualifiedName, publicId, systemId);
+}

package/dist/zip.browser.d.ts

@@ -0,0 +1,2 @@
+import type { ArchiveSource, ZipArchive } from "./adapters/interface.ts";
+export declare function openZip(source: ArchiveSource): Promise<ZipArchive>;

package/dist/zip.browser.js

@@ -0,0 +1,33 @@
+import { BlobReader, Uint8ArrayReader, Uint8ArrayWriter, ZipReader, } from "@zip.js/zip.js/lib/zip-core-native.js";
+import { openFile } from "#files";
+const MAX_APPENDED_DATA = 1024 * 1024;
+function toZipEntry(entry) {
+    return {
+        filename: entry.filename,
+        compressedSize: entry.compressedSize,
+        uncompressedSize: entry.uncompressedSize,
+        read: () => entry.getData(new Uint8ArrayWriter()),
+    };
+}
+export async function openZip(source) {
+    const data = typeof source === "string" ? await openFile(source) : source;
+    const reader = new ZipReader(data instanceof Uint8Array
+        ? new Uint8ArrayReader(data)
+        : new BlobReader(data), {
+        useWebWorkers: false,
+        // this in combination with maxAppendedDataSize is basically the manual fix
+        // we used to have for yauzl: sometimes zips has garbage at the end that
+        // would cause an error. zip.js has native support for this
+        strictness: "tolerant",
+        maxAppendedDataSize: MAX_APPENDED_DATA,
+        filenameValidation: "balanced",
+        checkCrc32: true,
+    });
+    const entries = await reader.getEntries();
+    return {
+        entries: entries
+            .filter((entry) => !entry.directory)
+            .map(toZipEntry),
+        close: () => reader.close(),
+    };
+}

package/dist/zip.node.d.ts

@@ -0,0 +1,9 @@
+import { Readable } from "node:stream";
+import type { ArchiveSource, ZipArchive, ZipEntry } from "./adapters/interface.ts";
+export interface NodeZipEntry extends ZipEntry {
+    openReadStream(): Promise<Readable>;
+}
+export interface NodeZipArchive extends ZipArchive, AsyncDisposable {
+    readonly entries: readonly NodeZipEntry[];
+}
+export declare function openZip(source: ArchiveSource): Promise<NodeZipArchive>;

package/dist/zip.node.js

@@ -0,0 +1,246 @@
+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 { createReadStream } from "node:fs";
+import { open as openFile, stat } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { Reader, fromBuffer, fromReader, } from "yauzl-promise";
+const EOCDR_SIGNATURE = Buffer.from([0x50, 0x4b, 0x05, 0x06]);
+const EOCDR_SIZE = 22;
+const MAX_TAIL_SCAN = 1024 * 1024;
+function toBuffer(source) {
+    return Buffer.isBuffer(source)
+        ? source
+        : Buffer.from(source.buffer, source.byteOffset, source.byteLength);
+}
+function findArchiveEnd(tail, tailStart, fileSize) {
+    let searchFrom = tail.length - EOCDR_SIZE;
+    while (searchFrom >= 0) {
+        const index = tail.lastIndexOf(EOCDR_SIGNATURE, searchFrom);
+        if (index === -1)
+            return null;
+        const commentLength = tail.readUInt16LE(index + 20);
+        const end = tailStart + index + EOCDR_SIZE + commentLength;
+        if (end < fileSize)
+            return end;
+        searchFrom = index - 1;
+    }
+    return null;
+}
+async function readExactly(handle, length, position) {
+    const buffer = Buffer.allocUnsafe(length);
+    let offset = 0;
+    while (offset < length) {
+        const { bytesRead } = await handle.read(buffer, offset, length - offset, position + offset);
+        if (bytesRead === 0)
+            return null;
+        offset += bytesRead;
+    }
+    return buffer;
+}
+/**
+ * Basically sometimes EPUB 2s have some garbage at the end of the file after
+ * the End of Central Directory Record, which leads to
+ * `yauzl` throwing an "End of Central Directory Record not found" error
+ *
+ * This is an attempt to, when that error happens, try to read the file from the end and find the End of Central Directory Record, then clean up the garbage at the end of the file.
+ */
+async function openTolerant(size, open, readTail) {
+    try {
+        return await open(size);
+    }
+    catch (error) {
+        const tailStart = Math.max(0, size - MAX_TAIL_SCAN);
+        const tail = await readTail(tailStart).catch(() => null);
+        const end = tail && findArchiveEnd(tail, tailStart, size);
+        if (!end)
+            throw error;
+        return await open(end).catch(() => {
+            throw error;
+        });
+    }
+}
+class FileHandleReader extends Reader {
+    path;
+    handle = null;
+    constructor(path) {
+        super();
+        this.path = path;
+    }
+    async _open() {
+        this.handle = await openFile(this.path, "r");
+        return {};
+    }
+    async _close() {
+        const handle = this.handle;
+        this.handle = null;
+        if (handle)
+            await handle.close();
+        return {};
+    }
+    async _read(start, length) {
+        if (!this.handle)
+            throw new Error(`reader for ${this.path} is not open`);
+        const buffer = await readExactly(this.handle, length, start);
+        if (!buffer) {
+            throw new Error(`unexpected end of file reading ${this.path}`);
+        }
+        return buffer;
+    }
+    _createReadStream(start, length) {
+        return createReadStream(this.path, { start, end: start + length - 1 });
+    }
+    async [Symbol.asyncDispose]() {
+        await this._close();
+    }
+}
+// yauzl-promise's own `open(path)` leaves the file open when parsing fails,
+// so we hand it a reader we close ourselves unless the zip takes it over
+async function openFileZip(path, size) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const cleanup = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const reader = cleanup.use(new FileHandleReader(path));
+        const zip = await fromReader(reader, size);
+        cleanup.move();
+        return zip;
+    }
+    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;
+    }
+}
+async function readFileTail(path, start) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const handle = __addDisposableResource(env_2, await openFile(path, "r"), true);
+        const { size } = await handle.stat();
+        return await readExactly(handle, size - start, start);
+    }
+    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;
+    }
+}
+class BlobReader extends Reader {
+    blob;
+    constructor(blob) {
+        super();
+        this.blob = blob;
+    }
+    async _read(start, length) {
+        return Buffer.from(await this.blob.slice(start, start + length).arrayBuffer());
+    }
+    _createReadStream(start, length) {
+        return Readable.fromWeb(this.blob.slice(start, start + length).stream());
+    }
+}
+function toZipEntry(entry) {
+    return {
+        filename: entry.filename,
+        compressedSize: entry.compressedSize,
+        uncompressedSize: entry.uncompressedSize,
+        openReadStream: () => entry.openReadStream(),
+        async read() {
+            const chunks = [];
+            for await (const chunk of await entry.openReadStream()) {
+                chunks.push(chunk);
+            }
+            return Buffer.concat(chunks);
+        },
+    };
+}
+async function openYauzl(source) {
+    if (typeof source === "string") {
+        return await openTolerant((await stat(source)).size, (size) => openFileZip(source, size), (start) => readFileTail(source, start));
+    }
+    if (source instanceof Uint8Array) {
+        const data = toBuffer(source);
+        return await openTolerant(data.length, (size) => fromBuffer(data.subarray(0, size)), (start) => Promise.resolve(data.subarray(start)));
+    }
+    return await openTolerant(source.size, (size) => fromReader(new BlobReader(source), size), async (start) => Buffer.from(await source.slice(start).arrayBuffer()));
+}
+export async function openZip(source) {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const cleanup = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
+        const zip = cleanup.adopt(await openYauzl(source), (zip) => zip.close());
+        const entries = await zip.readEntries();
+        const owned = cleanup.move();
+        return {
+            entries: entries
+                .filter((entry) => !entry.filename.endsWith("/"))
+                .map(toZipEntry),
+            close: () => owned.disposeAsync(),
+            [Symbol.asyncDispose]: () => owned.disposeAsync(),
+        };
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        const result_3 = __disposeResources(env_3);
+        if (result_3)
+            await result_3;
+    }
+}

package/package.json

@@ -1,12 +1,54 @@
 {
   "name": "@storyteller-platform/epub",
-  "version": "0.8.1",
+  "version": "1.0.0",
   "type": "module",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "exports": {
-    "types": "./dist/index.d.ts",
-    "default": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "default": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-dev-runtime.d.ts",
+      "default": "./dist/jsx-dev-runtime.js"
+    }
+  },
+  "imports": {
+    "#files": {
+      "node": {
+        "types": "./dist/files.node.d.ts",
+        "default": "./dist/files.node.js"
+      },
+      "default": {
+        "types": "./dist/files.browser.d.ts",
+        "default": "./dist/files.browser.js"
+      }
+    },
+    "#tmpfs": {
+      "node": {
+        "types": "./dist/adapters/tmpfs.d.ts",
+        "default": "./dist/adapters/tmpfs.js"
+      },
+      "default": {
+        "types": "./dist/adapters/tmpfs.browser.d.ts",
+        "default": "./dist/adapters/tmpfs.browser.js"
+      }
+    },
+    "#zip": {
+      "node": {
+        "types": "./dist/zip.node.d.ts",
+        "default": "./dist/zip.node.js"
+      },
+      "default": {
+        "types": "./dist/zip.browser.d.ts",
+        "default": "./dist/zip.browser.js"
+      }
+    }
   },
   "files": [
     "dist/"
@@ -29,7 +71,7 @@
     "@typescript/native": "npm:typescript@^7.0.2",
     "markdown-toc": "^1.2.0",
     "remark-toc": "^9.0.0",
-    "tsx": "^4.19.2",
+    "tsx": "^4.23.12",
     "typedoc": "^0.28.20",
     "typedoc-plugin-markdown": "^4.6.3",
     "typedoc-plugin-remark": "^1.2.0",
@@ -38,14 +80,12 @@
     "vitest": "^5.0.0"
   },
   "dependencies": {
-    "@readium/shared": "^2.2.0",
     "@storyteller-platform/fs": "^0.3.0",
     "@storyteller-platform/media-types": "^0.2.1",
     "@storyteller-platform/path": "^0.3.1",
-    "@zip.js/zip.js": "^2.0.0",
+    "@xmldom/xmldom": "^0.9.12",
+    "@zip.js/zip.js": "^2.18.2",
     "async-mutex": "^0.5.0",
-    "fast-xml-builder": "^1.3.1",
-    "fast-xml-parser": "^5.11.1",
     "mem": "^8.0.0",
     "nanoid": "^5.1.5",
     "yauzl-promise": "^4.0.0",
@@ -54,8 +94,50 @@
   "publishConfig": {
     "access": "public",
     "exports": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./jsx-runtime": {
+        "types": "./dist/jsx-runtime.d.ts",
+        "default": "./dist/jsx-runtime.js"
+      },
+      "./jsx-dev-runtime": {
+        "types": "./dist/jsx-dev-runtime.d.ts",
+        "default": "./dist/jsx-dev-runtime.js"
+      }
+    },
+    "imports": {
+      "#files": {
+        "node": {
+          "types": "./dist/files.node.d.ts",
+          "default": "./dist/files.node.js"
+        },
+        "default": {
+          "types": "./dist/files.browser.d.ts",
+          "default": "./dist/files.browser.js"
+        }
+      },
+      "#tmpfs": {
+        "node": {
+          "types": "./dist/adapters/tmpfs.d.ts",
+          "default": "./dist/adapters/tmpfs.js"
+        },
+        "default": {
+          "types": "./dist/adapters/tmpfs.browser.d.ts",
+          "default": "./dist/adapters/tmpfs.browser.js"
+        }
+      },
+      "#zip": {
+        "node": {
+          "types": "./dist/zip.node.d.ts",
+          "default": "./dist/zip.node.js"
+        },
+        "default": {
+          "types": "./dist/zip.browser.d.ts",
+          "default": "./dist/zip.browser.js"
+        }
+      }
     }
   }
 }