bookish-press 0.8.2 → 0.9.3

package/dist/epub/images.js

@@ -0,0 +1,260 @@
+/**
+ * Fetches a book's images and shrinks them to something an e-reader can hold.
+ *
+ * Books are written for the web, where a full resolution photograph is fine.
+ * E-ink devices are small, slow, and often storage constrained, so every image
+ * is re-encoded to fit the reader's chosen budget. The server-side thumbnails
+ * are no help here: they are 320px wide, below even the smallest preset.
+ *
+ * Every canvas reference lives inside a function rather than at module scope,
+ * because this module is imported during server rendering and during
+ * bookish-reader's prerender pass, and Node has no OffscreenCanvas.
+ */
+/**
+ * The presets offered to readers. Standard covers the common 6-7" e-ink panels
+ * at native resolution (Kobo Clara 1072x1448, Kindle Paperwhite 1236x1648);
+ * Compact targets pocket-sized greyscale readers; Large leaves room to zoom
+ * into diagrams on a tablet.
+ */
+export const SIZES = {
+    compact: {
+        id: 'compact',
+        label: 'Compact — small e-ink readers',
+        maxWidth: 480,
+        maxHeight: 640,
+        quality: 0.7,
+        grayscale: true,
+    },
+    standard: {
+        id: 'standard',
+        label: 'Standard — most e-readers',
+        // Just above the Kindle Paperwhite's 1236x1648, so a full-page image is
+        // never scaled down here only to be scaled back up by the device.
+        maxWidth: 1280,
+        maxHeight: 1720,
+        quality: 0.8,
+        grayscale: false,
+    },
+    large: {
+        id: 'large',
+        label: 'Large — tablets and zooming',
+        maxWidth: 1600,
+        maxHeight: 2200,
+        quality: 0.85,
+        grayscale: false,
+    },
+};
+export const DEFAULT_SIZE = SIZES.standard;
+/**
+ * The dimensions an image should be drawn at to fit within a budget, preserving
+ * its aspect ratio. Never enlarges: an image already smaller than the budget is
+ * left at its own size.
+ */
+export function fitWithin(width, height, maxWidth, maxHeight) {
+    if (width <= 0 || height <= 0)
+        return { width: 0, height: 0 };
+    const scale = Math.min(maxWidth / width, maxHeight / height, 1);
+    return {
+        width: Math.max(1, Math.round(width * scale)),
+        height: Math.max(1, Math.round(height * scale)),
+    };
+}
+/**
+ * How far past a budget an image may sit before it is shrunk even when its
+ * original encoding is smaller. Just over the budget is tolerated so a crisp
+ * original is not traded for a bigger resampled one; well past it is not,
+ * because the decode has to fit in the reader's memory.
+ */
+export const OVERSIZE_TOLERANCE = 1.5;
+/** Whether an image is far enough past a budget that it must be shrunk. */
+export function exceedsBudget(width, height, size) {
+    return (Math.max(width / size.maxWidth, height / size.maxHeight) >
+        OVERSIZE_TOLERANCE);
+}
+/** Media types EPUB 3 requires every reading system to support. */
+const PASS_THROUGH = {
+    'image/jpeg': { extension: 'jpg' },
+    'image/png': { extension: 'png' },
+    'image/gif': { extension: 'gif' },
+    'image/svg+xml': { extension: 'svg' },
+    'image/webp': { extension: 'webp' },
+};
+function passThrough(bytes, mediaType) {
+    const known = PASS_THROUGH[mediaType];
+    return known === undefined
+        ? { bytes, extension: 'jpg', mediaType: 'image/jpeg' }
+        : { bytes, extension: known.extension, mediaType };
+}
+/**
+ * Resolve an embed's URL to something fetchable. Local (non-http) URLs are
+ * relative to the book's base path, exactly as Embed.svelte resolves them --
+ * and in compiled books that base is frequently non-empty, so a bare
+ * `images/x.jpg` would 404.
+ */
+export function resolveImageURL(url, base) {
+    return url.startsWith('http') ? url : `${base}/images/${url}`;
+}
+/**
+ * How long to wait for a single image before giving up on it. Books link
+ * images on hosts we don't control, and a host that accepts a connection then
+ * never answers would otherwise hang the whole export: with a bounded number
+ * of fetches in flight, a few dead ones stall every remaining image behind
+ * them and the progress indicator sits there forever.
+ */
+const FETCH_TIMEOUT_MS = 20000;
+/**
+ * Fetch an image and re-encode it to fit the given budget.
+ *
+ * Returns undefined for anything that can't be fetched or decoded, which is a
+ * real possibility: authors may link images on hosts that send no CORS headers,
+ * or that are simply gone. Callers report those as warnings and drop the image,
+ * keeping its caption.
+ */
+export async function prepareImage(url, size) {
+    let bytes;
+    let mediaType;
+    try {
+        const response = await fetch(url, {
+            signal: typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal
+                ? AbortSignal.timeout(FETCH_TIMEOUT_MS)
+                : undefined,
+        });
+        if (!response.ok)
+            return undefined;
+        const blob = await response.blob();
+        bytes = new Uint8Array(await blob.arrayBuffer());
+        mediaType = blob.type || 'image/jpeg';
+    }
+    catch {
+        return undefined;
+    }
+    if (bytes.length === 0)
+        return undefined;
+    // SVG is resolution independent and usually tiny; rasterizing it is both
+    // wasteful and unreliable across browsers.
+    if (mediaType === 'image/svg+xml')
+        return passThrough(bytes, mediaType);
+    const reencoded = await reencode(bytes, mediaType, size);
+    if (reencoded === undefined)
+        return passThrough(bytes, mediaType);
+    // Keep whichever is smaller, since re-encoding can inflate a file: resizing
+    // a diagram resamples its hairlines into shades of grey, and the result can
+    // be larger than the crisp original. But an image far past the budget is
+    // shrunk regardless, because decoding it costs a small reader memory it may
+    // not have, and a few extra kilobytes are the cheaper price.
+    const { oversize, ...prepared } = reencoded;
+    return oversize || prepared.bytes.length < bytes.length
+        ? prepared
+        : passThrough(bytes, mediaType);
+}
+/**
+ * Draw the image at its budgeted size and encode it, reporting whether the
+ * original was far enough past the budget that it must be shrunk regardless of
+ * size. Returns undefined if the platform lacks the canvas APIs or the bytes
+ * don't decode.
+ */
+async function reencode(bytes, mediaType, size) {
+    if (typeof createImageBitmap === 'undefined' ||
+        typeof document === 'undefined')
+        return undefined;
+    let bitmap;
+    try {
+        bitmap = await createImageBitmap(new Blob([bytes], { type: mediaType }));
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const { width, height } = fitWithin(bitmap.width, bitmap.height, size.maxWidth, size.maxHeight);
+        if (width === 0 || height === 0)
+            return undefined;
+        const canvas = makeCanvas(width, height);
+        const context = canvas.getContext('2d');
+        if (context === null)
+            return undefined;
+        context.drawImage(bitmap, 0, 0, width, height);
+        if (size.grayscale)
+            desaturate(context, width, height);
+        // PNG first, while any transparency is still intact.
+        const png = await toBlob(canvas, 'image/png');
+        // Then white behind what is already drawn, because a JPEG has no alpha
+        // and transparent areas would otherwise come out black.
+        context.globalCompositeOperation = 'destination-over';
+        context.fillStyle = '#ffffff';
+        context.fillRect(0, 0, width, height);
+        context.globalCompositeOperation = 'source-over';
+        const jpeg = await toBlob(canvas, 'image/jpeg', size.quality);
+        const candidates = [];
+        if (jpeg !== null)
+            candidates.push({
+                bytes: new Uint8Array(await jpeg.arrayBuffer()),
+                extension: 'jpg',
+                mediaType: 'image/jpeg',
+            });
+        if (png !== null)
+            candidates.push({
+                bytes: new Uint8Array(await png.arrayBuffer()),
+                extension: 'png',
+                mediaType: 'image/png',
+            });
+        if (candidates.length === 0)
+            return undefined;
+        return {
+            // Whichever encoding came out smaller: JPEG wins on photographs,
+            // PNG on the flat colors and hairlines of a diagram.
+            ...candidates.reduce((a, b) => b.bytes.length < a.bytes.length ? b : a),
+            oversize: exceedsBudget(bitmap.width, bitmap.height, size),
+        };
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        bitmap.close();
+    }
+}
+function makeCanvas(width, height) {
+    if (typeof OffscreenCanvas !== 'undefined')
+        return new OffscreenCanvas(width, height);
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+}
+function toBlob(canvas, type, quality) {
+    return 'convertToBlob' in canvas
+        ? canvas.convertToBlob({ type, quality }).catch(() => null)
+        : new Promise((resolve) => canvas.toBlob((blob) => resolve(blob), type, quality));
+}
+/** Replace each pixel with its luminance, weighted the way human vision is. */
+function desaturate(context, width, height) {
+    const image = context.getImageData(0, 0, width, height);
+    const pixels = image.data;
+    for (let i = 0; i < pixels.length; i += 4) {
+        const luminance = 0.2126 * pixels[i] +
+            0.7152 * pixels[i + 1] +
+            0.0722 * pixels[i + 2];
+        pixels[i] = luminance;
+        pixels[i + 1] = luminance;
+        pixels[i + 2] = luminance;
+    }
+    context.putImageData(image, 0, 0);
+}
+/**
+ * Run tasks with a bounded number in flight, so a book with a hundred images
+ * doesn't open a hundred connections at once.
+ */
+export async function mapWithLimit(items, limit, map) {
+    const results = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            results[index] = await map(items[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/epub/images.test.d.ts

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

package/dist/epub/images.test.js

@@ -0,0 +1,129 @@
+import { expect, test } from 'vitest';
+import { DEFAULT_SIZE, exceedsBudget, fitWithin, mapWithLimit, resolveImageURL, SIZES, } from './images';
+test('shrinks a landscape image to the width budget', () => {
+    expect(fitWithin(2400, 1200, 1200, 1600)).toEqual({
+        width: 1200,
+        height: 600,
+    });
+});
+test('shrinks a portrait image to the height budget', () => {
+    expect(fitWithin(1200, 3200, 1200, 1600)).toEqual({
+        width: 600,
+        height: 1600,
+    });
+});
+test('never enlarges an image that already fits', () => {
+    expect(fitWithin(320, 240, 1200, 1600)).toEqual({
+        width: 320,
+        height: 240,
+    });
+});
+test('preserves aspect ratio when both dimensions exceed the budget', () => {
+    const { width, height } = fitWithin(4000, 3000, 1200, 1600);
+    expect(width).toBe(1200);
+    expect(height).toBe(900);
+    expect(width / height).toBeCloseTo(4000 / 3000, 5);
+});
+test('never rounds a dimension away to nothing', () => {
+    // An extreme panorama would otherwise round its height to 0.
+    const { width, height } = fitWithin(10000, 3, 480, 640);
+    expect(width).toBeGreaterThan(0);
+    expect(height).toBeGreaterThan(0);
+});
+test('treats a degenerate image as empty rather than dividing by zero', () => {
+    expect(fitWithin(0, 0, 1200, 1600)).toEqual({ width: 0, height: 0 });
+    expect(fitWithin(-5, 10, 1200, 1600)).toEqual({ width: 0, height: 0 });
+});
+test('every preset is smaller than the next and shaped for its device', () => {
+    const { compact, standard, large } = SIZES;
+    expect(compact.maxWidth).toBeLessThan(standard.maxWidth);
+    expect(standard.maxWidth).toBeLessThan(large.maxWidth);
+    expect(compact.maxHeight).toBeLessThan(standard.maxHeight);
+    expect(standard.maxHeight).toBeLessThan(large.maxHeight);
+    // Pocket e-ink panels are greyscale; the bigger presets are read on
+    // devices that can show color.
+    expect(compact.grayscale).toBe(true);
+    expect(standard.grayscale).toBe(false);
+    expect(large.grayscale).toBe(false);
+    for (const size of Object.values(SIZES)) {
+        expect(size.quality).toBeGreaterThan(0);
+        expect(size.quality).toBeLessThanOrEqual(1);
+        expect(size.label.length).toBeGreaterThan(0);
+    }
+});
+test('every preset is keyed by its own id', () => {
+    for (const [key, size] of Object.entries(SIZES))
+        expect(size.id).toBe(key);
+});
+test('the default is one of the presets', () => {
+    expect(SIZES[DEFAULT_SIZE.id]).toBe(DEFAULT_SIZE);
+});
+// Standard has to cover the common panels at native resolution, or images
+// would be upscaled by the device and look worse than the web version.
+test('the standard preset covers common e-ink panels at native resolution', () => {
+    const { standard } = SIZES;
+    for (const [width, height] of [
+        [1072, 1448], // Kobo Clara
+        [1236, 1648], // Kindle Paperwhite
+    ]) {
+        const fitted = fitWithin(width, height, standard.maxWidth, standard.maxHeight);
+        expect(fitted.width).toBeGreaterThanOrEqual(width);
+        expect(fitted.height).toBeGreaterThanOrEqual(height);
+    }
+});
+test('resolves a remote image URL unchanged', () => {
+    expect(resolveImageURL('https://example.com/a.jpg', '/base')).toBe('https://example.com/a.jpg');
+});
+// Compiled books are often served from a subdirectory, so a bare `images/x`
+// would miss.
+test('resolves a local image URL against the book base path', () => {
+    expect(resolveImageURL('a.jpg', '/ajko/books/design-methods')).toBe('/ajko/books/design-methods/images/a.jpg');
+});
+test('resolves a local image URL when the book is at the root', () => {
+    expect(resolveImageURL('a.jpg', '')).toBe('/images/a.jpg');
+});
+test('maps every item, in order, with results aligned to inputs', async () => {
+    const items = [1, 2, 3, 4, 5, 6, 7];
+    const doubled = await mapWithLimit(items, 3, async (n) => n * 2);
+    expect(doubled).toEqual([2, 4, 6, 8, 10, 12, 14]);
+});
+test('never exceeds the concurrency limit', async () => {
+    let running = 0;
+    let peak = 0;
+    await mapWithLimit(Array.from({ length: 20 }, (_, i) => i), 4, async () => {
+        running++;
+        peak = Math.max(peak, running);
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        running--;
+    });
+    expect(peak).toBeLessThanOrEqual(4);
+    expect(peak).toBeGreaterThan(1);
+});
+test('handles fewer items than the limit', async () => {
+    expect(await mapWithLimit([1], 8, async (n) => n)).toEqual([1]);
+});
+test('handles no items at all', async () => {
+    expect(await mapWithLimit([], 4, async (n) => n)).toEqual([]);
+});
+// The rule that decides whether a crisp original may stay, or has to be
+// resampled even though that can make the file bigger.
+test('tolerates an image just past the budget', () => {
+    // 1600x1200 against Standard's 1280x1720: 1.25x on the long edge. Resizing
+    // line art this close to budget can double its size for no real gain.
+    expect(exceedsBudget(1600, 1200, SIZES.standard)).toBe(false);
+});
+test('does not tolerate an image well past the budget', () => {
+    expect(exceedsBudget(900, 900, SIZES.compact)).toBe(true);
+    expect(exceedsBudget(2400, 1600, SIZES.standard)).toBe(true);
+});
+test('measures the budget on whichever edge binds', () => {
+    // A panorama busts the width budget while sitting well inside the height.
+    expect(exceedsBudget(3000, 600, SIZES.standard)).toBe(true);
+    // A tall image busts the height budget while sitting inside the width.
+    expect(exceedsBudget(400, 2400, SIZES.compact)).toBe(true);
+});
+test('never asks to shrink an image that already fits', () => {
+    for (const size of Object.values(SIZES))
+        expect(exceedsBudget(size.maxWidth, size.maxHeight, size)).toBe(false);
+    expect(exceedsBudget(100, 100, SIZES.compact)).toBe(false);
+});

package/dist/epub/package.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Assembles the documents that make up an EPUB 3 package.
+ *
+ * Nothing here touches the network or the DOM, so it can be unit tested and is
+ * safe to import during server rendering.
+ */
+import type Edition from '../models/book/Edition';
+import type Chapter from '../models/book/Chapter';
+import { type SerializationContext } from './xhtml';
+export declare const MIMETYPE = "application/epub+zip";
+/** Where the package's documents live inside the archive. */
+export declare const CONTENT_DIRECTORY = "OEBPS";
+export declare const CONTAINER = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<container version=\"1.0\" xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\">\n<rootfiles>\n<rootfile full-path=\"OEBPS/content.opf\" media-type=\"application/oebps-package+xml\"/>\n</rootfiles>\n</container>";
+/**
+ * The packaged stylesheet.
+ *
+ * Two rules govern it. First, it sets no typeface and no absolute size for
+ * prose: e-reader users choose their own, and overriding that is the most
+ * common way an EPUB becomes unpleasant to read. (Code is the one exception --
+ * code that doesn't look like code is just wrong.) The book's own theme is not
+ * carried across either, since it imports fonts an offline reader can't fetch
+ * and encodes color e-ink can't show.
+ *
+ * Second, and learned the hard way on an XTeink X3: it assumes the reading
+ * system has *no* default stylesheet. Small readers often have barely any, so
+ * anything left unsaid is left unrendered -- headings came out all one size,
+ * ordered lists came out bulleted, and a definition list ran together into a
+ * paragraph. Every element the serializer can emit is given its display,
+ * spacing and emphasis here rather than being assumed. The contract test in
+ * stylesheet.test.ts derives that element list from the serializer itself, so
+ * a new node type that emits a new element fails until this file covers it.
+ */
+export declare const STYLESHEET = "/* Reading systems with a minimal default stylesheet render unknown elements\n   inline, so every block element states that it is one. */\narticle, aside, details, div, dl, dd, dt, figcaption, figure, footer,\nheader, hgroup, main, nav, section, blockquote, p, h1, h2, h3, h4, h5, h6,\nhr, ol, ul, pre { display: block; }\nli { display: list-item; }\ntable { display: table; }\nthead { display: table-header-group; }\ntbody { display: table-row-group; }\ntr { display: table-row; }\nth, td { display: table-cell; }\ncaption { display: table-caption; }\n\nbody { margin: 0 5%; line-height: 1.5; widows: 2; orphans: 2; }\n\n/* An explicit scale, in em so the reader's chosen size still governs. Without\n   it a reader with no defaults renders every level at body size. */\nh1, h2, h3, h4, h5, h6 {\n    font-weight: bold;\n    line-height: 1.2;\n    margin: 1.2em 0 0.6em;\n    page-break-after: avoid;\n    break-after: avoid;\n}\nh1 { font-size: 1.6em; margin: 2em 0 1em; }\nh2 { font-size: 1.35em; }\nh3 { font-size: 1.2em; }\nh4 { font-size: 1.1em; }\nh5 { font-size: 1em; }\nh6 { font-size: 0.9em; }\n\np { margin: 0; text-indent: 1.2em; }\n/* The first paragraph of a section is not a continuation, so it isn't indented. */\np.first, h1 + p, h2 + p, h3 + p, h4 + p, h5 + p, h6 + p,\nblockquote p:first-child, li > p:first-child { text-indent: 0; }\n\nstrong { font-weight: bold; }\nem { font-style: italic; }\nsup { vertical-align: super; font-size: 0.75em; line-height: 0; }\nsub { vertical-align: sub; font-size: 0.75em; line-height: 0; }\na { text-decoration: underline; }\n\n.chapter-number { display: block; margin-bottom: 0.5em; text-transform: uppercase; letter-spacing: 0.1em; font-size: 0.8em; }\n.section-name { display: block; font-style: italic; }\n.authors { display: block; font-style: italic; }\n\nfigure { margin: 1.5em 0; text-align: center; page-break-inside: avoid; break-inside: avoid; }\nimg { max-width: 100%; }\nfigcaption { font-size: 0.85em; text-align: left; margin-top: 0.5em; }\nfigcaption p { margin: 0; text-indent: 0; }\n.credit { font-style: italic; }\n.missing-image figcaption { text-align: center; font-style: italic; }\n\nblockquote { margin: 1.5em 2em; font-style: italic; }\nblockquote p { text-indent: 0; }\ncite { font-style: normal; font-size: 0.85em; }\n\n.callout { margin: 1.5em 1em; padding-left: 1em; border-left: 3px solid currentColor; }\n.callout p { text-indent: 0; }\n\n/* The one place a family is set: monospace is what distinguishes code from\n   prose, and without it the two are indistinguishable. */\npre, code, pre code, kbd, samp { font-family: monospace; }\npre { font-size: 0.8em; white-space: pre-wrap; overflow-wrap: break-word; margin: 1.5em 0; }\ncode { font-size: 0.9em; }\n\ntable { border-collapse: collapse; margin: 1.5em auto; font-size: 0.9em; }\nth, td { border: 1px solid currentColor; padding: 0.3em 0.5em; text-align: left; }\nth { font-weight: bold; }\ncaption { font-size: 0.85em; margin-bottom: 0.5em; }\ncaption p { margin: 0; text-indent: 0; }\n\n/* Outside, so a wrapped item hangs with its text aligned rather than tucking\n   under the marker. Types are stated because a reader with no defaults numbers\n   nothing, and mirror how the web reader nests them. */\nul, ol { margin: 1em 0; padding-left: 1.5em; list-style-position: outside; }\nul { list-style-type: disc; }\nul ul { list-style-type: circle; }\nul ul ul { list-style-type: square; }\nol { list-style-type: decimal; }\nol ol { list-style-type: lower-alpha; }\nol ol ol { list-style-type: upper-alpha; }\nli { margin-bottom: 0.25em; }\n\nhr { border: 0; border-top: 1px solid currentColor; margin: 2em auto; width: 30%; }\n\n.citation, .noteref { font-size: 0.75em; }\n.notes { margin-top: 3em; font-size: 0.9em; page-break-before: always; break-before: page; }\n.note { margin-bottom: 0.5em; }\n.note p { text-indent: 0; margin-bottom: 0.5em; }\n\n.reference { margin-bottom: 0.8em; }\n\n/* The glossary is paragraphs rather than a definition list: see\n   glossaryDocument. Terms and meanings are distinguished by class. */\n.definition { margin-bottom: 1em; }\n.term { font-weight: bold; text-indent: 0; margin-top: 1em; }\n.meaning { text-indent: 0; margin-left: 1.5em; }\n.synonyms { font-size: 0.85em; font-style: italic; text-indent: 0; margin: 0.25em 0 0 1.5em; }\n";
+/** One document in the package. */
+export type Document = {
+    /** Path relative to the content directory. */
+    path: string;
+    /** Manifest id. */
+    id: string;
+    content: string;
+    /** Title as it should appear in the navigation, or undefined to omit it. */
+    navTitle?: string;
+};
+/** An image that made it into the package. */
+export type PackagedImage = {
+    path: string;
+    id: string;
+    mediaType: string;
+    bytes: Uint8Array;
+    /** True for the book's cover image. */
+    cover?: boolean;
+};
+/** Chapters that get their own document, in reading order. */
+export declare function includedChapters(edition: Edition): Chapter[];
+/** Turn a title into something usable as a filename. */
+export declare function safeFilename(title: string): string;
+/** The title page, which carries the metadata a reader wants up front. */
+export declare function titleDocument(edition: Edition, context: SerializationContext): Document;
+/** A page that displays the cover image, which some readers expect. */
+export declare function coverDocument(imagePath: string): Document;
+/** One chapter, with its footnotes gathered into endnotes at the end. */
+export declare function chapterDocument(edition: Edition, chapter: Chapter, context: SerializationContext): Document | undefined;
+/** The references back matter, whose anchors the citations link to. */
+export declare function referencesDocument(edition: Edition, context: SerializationContext): Document | undefined;
+/** The glossary back matter, whose anchors the definitions link to. */
+export declare function glossaryDocument(edition: Edition, context: SerializationContext): Document | undefined;
+/** The EPUB 3 navigation document. */
+export declare function navigationDocument(documents: Document[]): Document;
+/**
+ * The EPUB 2 navigation document. Superseded by nav.xhtml, but older Kindle and
+ * Kobo firmware still looks for it, and it costs a few hundred bytes.
+ */
+export declare function ncxDocument(identifier: string, title: string, documents: Document[]): string;
+/** The package document: metadata, manifest, and reading order. */
+export declare function packageDocument(edition: Edition, identifier: string, documents: Document[], images: PackagedImage[], modified: Date): string;