@d-i-t-a/reader 3.0.0-alpha.14 → 3.0.0-alpha.16

package/dist/types/fetcher/Base64DecodingFetcher.d.ts

@@ -0,0 +1,19 @@
+import type { Link } from "../model/v3";
+import type { Fetcher, Resource } from "./Fetcher";
+/**
+ * Wraps an inner Fetcher and base64-decodes document responses when
+ * needed. Composed into the chain when `RequestConfig.encoded === true`.
+ *
+ * Detects encoding by first character: document content starts with `<`;
+ * base64 doesn't. If text is already a document, pass through. Otherwise
+ * attempt atob; if atob succeeds, use the result.
+ */
+export declare class Base64DecodingFetcher implements Fetcher {
+    private readonly inner;
+    constructor(inner: Fetcher);
+    get(link: Link): Promise<Resource>;
+    getByHref(href: string): Promise<Resource>;
+    cancel(href: string): void;
+    destroy(): void;
+    private maybeDecode;
+}

package/dist/types/fetcher/BlobUrlManager.d.ts

@@ -0,0 +1,91 @@
+import type { Container } from "./Container";
+import type { Resource } from "./Fetcher";
+import type { EncryptionInfo } from "./FontDeobfuscator";
+import { ZipFetcher } from "./ZipFetcher";
+/**
+ * A transform applied to resources before creating blob URLs.
+ * Same signature as ResourceTransform from TransformingFetcher.
+ */
+type BlobTransform = (resource: Resource) => Resource | Promise<Resource>;
+/**
+ * Creates and manages blob URLs for resources in a Container.
+ *
+ * When opening an .epub file directly, the browser can't fetch images,
+ * CSS, fonts, and scripts from the archive because they don't exist
+ * at any HTTP URL. This manager creates blob URLs for each resource
+ * so they can be referenced in document.write() iframe content.
+ *
+ * Transforms (e.g., font deobfuscation) can be applied to resources
+ * before blob URLs are created via `addTransform()`.
+ *
+ * After parsing HTML content with DOMParser, call `rewriteDom(doc, baseDir)`
+ * to replace relative src/href attributes with blob URLs. This works at
+ * the DOM level — no regex on raw HTML.
+ *
+ * Call `destroy()` when done to revoke all blob URLs and free memory.
+ */
+export declare class BlobUrlManager {
+    private blobUrls;
+    private readonly container;
+    private transforms;
+    private encryptionMap?;
+    constructor(source: Container | ZipFetcher);
+    /**
+     * Set encryption metadata so Resources built during initialize()
+     * carry `properties.encrypted`. Transforms (e.g., deobfuscation)
+     * read this to know which resources to process.
+     */
+    setEncryptionMap(map: Map<string, EncryptionInfo>): void;
+    /**
+     * Add a transform applied to resources before blob URL creation.
+     * Transforms run in order. Must be called before initialize().
+     *
+     * Example: font deobfuscation
+     * ```ts
+     * manager.addTransform(createDeobfuscationTransform(identifier));
+     * ```
+     */
+    addTransform(transform: BlobTransform): void;
+    /**
+     * Create blob URLs for all resources in the container.
+     * Call once after construction and addTransform().
+     *
+     * Two-pass process:
+     * 1. Create blob URLs for all non-CSS resources (images, fonts, etc.)
+     *    — applies any registered transforms before creating the blob URL.
+     * 2. Process CSS files — rewrite internal url() references to the
+     *    blob URLs from pass 1, THEN create blob URLs for the rewritten CSS.
+     *
+     * This ensures that when the browser loads a CSS file via its blob URL,
+     * font/image/background references inside it also point to blob URLs.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Rewrite resource references in a parsed DOM to blob URLs.
+     *
+     * Traverses the document and replaces relative `src`, `href`, and
+     * `xlink:href` attributes on img, link, script, image, use, audio,
+     * video, and source elements with their corresponding blob URLs.
+     *
+     * Also strips any Content-Security-Policy meta tags that would block
+     * the injected ReadiumCSS stylesheets.
+     *
+     * @param doc — the parsed XHTML document
+     * @param currentPath — the ZIP-internal path of the current HTML file
+     *   (e.g., "OEBPS/Text/chapter1.xhtml"). Used to resolve relative URLs.
+     */
+    rewriteDom(doc: Document, currentPath: string): void;
+    /**
+     * Rewrite url() and @import references in CSS text.
+     *
+     * Handles:
+     * - `url("path")` / `url('path')` / `url(path)` — standard references
+     * - `@import url("path")` — url()-form imports (caught by the url() regex)
+     * - `@import "path"` / `@import 'path'` — bare string imports
+     */
+    private rewriteCssUrls;
+    private isAbsolute;
+    private resolve;
+    destroy(): void;
+}
+export {};

package/dist/types/fetcher/CacheFetcher.d.ts

@@ -0,0 +1,36 @@
+import type { Link } from "../model/v3";
+import type { Fetcher, Resource } from "./Fetcher";
+/**
+ * Caching wrapper around any Fetcher.
+ *
+ * Caches fetched resources by href in memory. Serves subsequent
+ * requests from cache without hitting the inner Fetcher. Enables
+ * predictive spine prefetching — the navigator calls `prefetch(link)`
+ * after each resource loads, and the next chapter is already in memory
+ * when the user turns the page.
+ *
+ * Memory management: call `evict(href)` to remove specific entries,
+ * or `clear()` to drop all cached resources.
+ */
+export declare class CacheFetcher implements Fetcher {
+    private readonly inner;
+    private cache;
+    private pending;
+    constructor(inner: Fetcher);
+    get(link: Link): Promise<Resource>;
+    getByHref(href: string): Promise<Resource>;
+    /**
+     * Prefetch a resource into cache without blocking.
+     * Used by the navigator to preload adjacent spine items after
+     * the current resource finishes loading.
+     */
+    prefetch(link: Link): Promise<void>;
+    /** Check if a resource is cached. */
+    has(link: Link): Promise<boolean>;
+    /** Remove a specific resource from cache. */
+    evict(href: string): void;
+    /** Drop all cached resources. */
+    clear(): void;
+    cancel(href: string): void;
+    destroy(): void;
+}

package/dist/types/fetcher/Container.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Read-only container of named entries.
+ *
+ * A Container provides access to a collection of resources by path.
+ * It knows what entries exist and can return their raw bytes, but
+ * doesn't know anything about Fetcher, Resource, or media types.
+ *
+ * Implementations:
+ * - ZipContainer — entries from a ZIP archive (EPUB, CBZ)
+ * - Future: HttpContainer, FileSystemContainer, etc.
+ */
+export interface Container {
+    /** All entry paths in the container. */
+    entries(): string[];
+    /** Get raw bytes for an entry, or undefined if not found. */
+    get(path: string): Uint8Array | undefined;
+    /** Check if an entry exists. */
+    has(path: string): boolean;
+    /** Release resources (close file handles, free memory). */
+    destroy(): void;
+}

package/dist/types/fetcher/ContentFetcher.d.ts

@@ -0,0 +1,32 @@
+import type { Link } from "../model/v3";
+import type { GetContent } from "./types";
+import type { Fetcher, Resource } from "./Fetcher";
+import type { Publication } from "../model/v3";
+/**
+ * Fetcher that delegates publication-resource requests to the integrator's
+ * `api.getContent` callback.
+ *
+ * For hrefs that belong to the publication (readingOrder + resources in
+ * the manifest), `getContent(href)` is called first. If the integrator
+ * returns content, that content is used. If it returns `undefined`, the
+ * request falls through to the inner Fetcher.
+ *
+ * Requests for hrefs NOT in the manifest — positions service, external
+ * links, browser-chrome URLs — pass straight through to the inner Fetcher
+ * without touching getContent.
+ *
+ * Integrators use `api.getContent` to serve protected/licensed content,
+ * fetch from a custom source, or transform content before it reaches the
+ * reader.
+ */
+export declare class ContentFetcher implements Fetcher {
+    private readonly inner;
+    private readonly getContent;
+    private readonly publicationResourceHrefs;
+    constructor(inner: Fetcher, getContent: GetContent, publication: Publication);
+    get(link: Link): Promise<Resource>;
+    getByHref(href: string): Promise<Resource>;
+    cancel(href: string): void;
+    destroy(): void;
+    private isPublicationResource;
+}

package/dist/types/fetcher/EpubParser.d.ts

@@ -0,0 +1,48 @@
+import { Publication } from "../model/v3/Publication";
+import type { ZipFetcher } from "./ZipFetcher";
+/**
+ * Client-side EPUB parser.
+ *
+ * Reads an EPUB archive (via ZipFetcher) and produces a Publication
+ * (Readium RWPM format). Handles EPUB 2 and EPUB 3:
+ *
+ * 1. META-INF/container.xml → find the OPF rootfile path
+ * 2. OPF → parse metadata, manifest items, spine, TOC
+ * 3. Convert to the normalized JSON shape that Publication.fromJSON() expects
+ *
+ * Metadata: title, language, identifier, authors, publisher, description,
+ * subjects, published date, modified date, numberOfPages, layout,
+ * readingProgression, rendition properties, media overlay classes.
+ *
+ * Spine: reading order with page-spread properties, linear="no" filtering,
+ * page-progression-direction.
+ *
+ * Resources: non-spine manifest items + non-linear spine items, cover image
+ * detection (EPUB3 cover-image property + EPUB2 meta name="cover").
+ *
+ * TOC: EPUB3 nav document with fallback to EPUB2 NCX.
+ */
+export declare class EpubParser {
+    /**
+     * Extract just the dc:identifier from an EPUB without full parsing.
+     * Used to generate a unique synthetic URL before the full parse.
+     */
+    static extractIdentifier(zip: ZipFetcher): Promise<string>;
+    /**
+     * Parse an EPUB from a ZipFetcher and return a Publication.
+     *
+     * @param zip — ZipFetcher wrapping the .epub archive
+     * @param baseUrl — synthetic base URL for the publication
+     *   (e.g. `blob:...` or `epub://local/`). Used for href resolution.
+     */
+    static parse(zip: ZipFetcher, baseUrl: URL): Promise<Publication>;
+    /**
+     * Parse the EPUB 3 nav document (XHTML) to extract the TOC.
+     * Looks for `<nav epub:type="toc">` and extracts the `<ol>` structure.
+     */
+    private static parseNavToc;
+    /**
+     * Parse an EPUB2 NCX table of contents.
+     */
+    private static parseNcxToc;
+}

package/dist/types/fetcher/Fetcher.d.ts

@@ -0,0 +1,111 @@
+import type { Link } from "../model/v3";
+/**
+ * A fetched resource — the result of a Fetcher.get() call.
+ *
+ * Represents content retrieved from any source (HTTP, ZIP, cache,
+ * decryption pipeline). Consumers read `text` for string content
+ * (HTML, XML, JSON) or `bytes` for binary content (images, audio, PDF).
+ *
+ * The `partial` and `range` fields are reserved for future range/partial
+ * fetching (DRM workstream — page-level streaming). Fetchers that support
+ * partial content set these; consumers that don't need partial content
+ * ignore them.
+ */
+export interface Resource {
+    /** The resolved content as a string (HTML, XML, JSON, etc.) */
+    readonly text: string;
+    /** The raw bytes — for binary content (images, audio, PDF) */
+    readonly bytes?: ArrayBuffer;
+    /** HTTP headers or equivalent metadata */
+    readonly headers: Record<string, string>;
+    /** The media type (e.g. "application/xhtml+xml", "application/pdf") */
+    readonly mediaType: string;
+    /** The resolved href */
+    readonly href: string;
+    /**
+     * Extensible metadata about this resource.
+     *
+     * Used to carry information through the Fetcher chain that
+     * isn't part of the content itself:
+     * - `encrypted?: { algorithm: string; originalLength?: number }` —
+     *   encryption/obfuscation info from encryption.xml
+     * - `filename?: string` — original filename from the container
+     * - Custom properties set by TransformingFetcher or integrators
+     */
+    readonly properties?: Record<string, unknown>;
+    /**
+     * Reserved for future range/partial fetching (3.9).
+     * True if this resource contains a partial range, not the full content.
+     */
+    readonly partial?: boolean;
+    /**
+     * Reserved for future range/partial fetching (3.9).
+     * The byte range this resource represents within the full content.
+     */
+    readonly range?: {
+        start: number;
+        end: number;
+        total: number;
+    };
+}
+/**
+ * Content loading abstraction.
+ *
+ * All content in the reader flows through a Fetcher — chapter HTML,
+ * media overlay manifests, audio files, footnote popups, search content.
+ * The navigator and modules call `fetcher.get(link)` and receive a
+ * Resource without knowing where the content came from (HTTP, ZIP,
+ * cache, decryption pipeline).
+ *
+ * Fetchers are composable — stack them to build a content pipeline:
+ *
+ * ```ts
+ * // Server-based with decryption + caching:
+ * const fetcher = new CacheFetcher(
+ *   new ContentFetcher(
+ *     new HttpFetcher(requestConfig),
+ *     api.getContent
+ *   )
+ * )
+ *
+ * // Client-side EPUB with caching:
+ * const fetcher = new CacheFetcher(
+ *   new ZipFetcher(epubBlob)
+ * )
+ * ```
+ */
+export interface Fetcher {
+    /**
+     * Fetch a resource by Link.
+     * Returns a Resource with the content, headers, and media type.
+     * Throws ReadError on failure (access, decoding, or cancelled).
+     */
+    get(link: Link): Promise<Resource>;
+    /**
+     * Fetch a resource by href string (convenience overload).
+     * Throws ReadError on failure.
+     */
+    getByHref(href: string): Promise<Resource>;
+    /**
+     * Cancel an in-flight fetch for the given href.
+     * Optional — not all Fetcher implementations support cancellation.
+     */
+    cancel?(href: string): void;
+    /**
+     * Check if a resource is available without fetching it.
+     * Optional — useful for CacheFetcher (check cache hit) and
+     * ZipFetcher (check if file exists in ZIP).
+     */
+    has?(link: Link): Promise<boolean>;
+    /**
+     * Prefetch a resource into cache without blocking.
+     * Optional — only meaningful for Fetchers that cache (CacheFetcher).
+     * Non-caching Fetchers can ignore this or no-op.
+     */
+    prefetch?(link: Link): Promise<void>;
+    /**
+     * Release resources held by this Fetcher (close ZIP handles,
+     * clear caches, abort pending requests).
+     */
+    destroy?(): void;
+}

package/dist/types/fetcher/FontDeobfuscator.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Font deobfuscation for EPUB archives.
+ *
+ * EPUB publishers can obfuscate embedded fonts to prevent casual reuse
+ * outside the publication. Two algorithms exist:
+ *
+ * - **IDPF** (`http://www.idpf.org/2008/embedding`):
+ *   SHA-1 hash of the publication identifier, XOR first 1040 bytes.
+ *
+ * - **Adobe** (`http://ns.adobe.com/pdf/enc#RC`):
+ *   UUID from the identifier (16 bytes), XOR first 1024 bytes.
+ *
+ * The encryption.xml file in META-INF lists which resources are
+ * obfuscated and with which algorithm. The publication's dc:identifier
+ * is used to derive the deobfuscation key.
+ *
+ * Reference implementations:
+ * - edrlab/r2-shared-js src/transform/transformer-obf-idpf.ts
+ * - edrlab/r2-shared-js src/transform/transformer-obf-adobe.ts
+ * - readium/swift-toolkit Sources/Streamer/Parser/EPUB/EPUBDeobfuscator.swift
+ */
+/** Algorithm URIs as defined in the EPUB spec and Adobe's scheme. */
+export declare const ALGORITHM_IDPF = "http://www.idpf.org/2008/embedding";
+export declare const ALGORITHM_ADOBE = "http://ns.adobe.com/pdf/enc#RC";
+/** Encryption info for a single resource, parsed from encryption.xml. */
+export interface EncryptionInfo {
+    algorithm: string;
+    /** Original uncompressed length (from EncryptionProperties, if present). */
+    originalLength?: number;
+}
+/**
+ * Parse META-INF/encryption.xml and return a map of href → EncryptionInfo.
+ *
+ * Only extracts entries with IDPF or Adobe obfuscation algorithms.
+ * Other encryption types (e.g., LCP AES-256) are ignored here —
+ * those are handled by the integrator's getContent callback.
+ */
+export declare function parseEncryptionXml(xmlText: string): Map<string, EncryptionInfo>;
+/**
+ * Deobfuscate font data using the IDPF algorithm.
+ *
+ * SHA-1 hash of the identifier → XOR first 1040 bytes.
+ * Uses Web Crypto API (available in all modern browsers).
+ */
+export declare function deobfuscateIdpf(data: Uint8Array, identifier: string): Promise<Uint8Array>;
+/**
+ * Deobfuscate font data using the Adobe algorithm.
+ *
+ * Extract UUID from identifier (strip urn:uuid:, hyphens, whitespace),
+ * convert 16 hex pairs to 16 bytes → XOR first 1024 bytes.
+ */
+export declare function deobfuscateAdobe(data: Uint8Array, identifier: string): Uint8Array;
+/**
+ * Create a ResourceTransform that deobfuscates fonts based on
+ * encryption info stored in the Resource's `properties.encrypted`.
+ *
+ * Use with TransformingFetcher:
+ * ```ts
+ * new TransformingFetcher(inner, createDeobfuscationTransform(identifier))
+ * ```
+ *
+ * Resources without encryption properties pass through unchanged.
+ * Only IDPF and Adobe algorithms are handled.
+ */
+export declare function createDeobfuscationTransform(identifier: string): (resource: import("./Fetcher").Resource) => Promise<import("./Fetcher").Resource>;

package/dist/types/fetcher/HttpFetcher.d.ts

@@ -0,0 +1,29 @@
+import type { Link } from "../model/v3";
+import type { RequestConfig } from "./types";
+import type { Fetcher, Resource } from "./Fetcher";
+/**
+ * Default Fetcher implementation — loads resources via HTTP `fetch()`.
+ *
+ * Drop-in replacement for the current direct `fetch()` calls scattered
+ * across EpubNavigator, SearchModule, MediaOverlayModule, and Popup.
+ * Existing integrators get this automatically without changing anything.
+ *
+ * Handles:
+ * - Custom headers, credentials, and other RequestInit options via `requestConfig`
+ * - Media type detection from Content-Type header
+ *
+ * Base64-encoded content is handled by `Base64DecodingFetcher`, not here.
+ * HttpFetcher returns the response body as plain text. Decoding is
+ * composed in when `requestConfig.encoded` is true.
+ */
+export declare class HttpFetcher implements Fetcher {
+    private readonly requestConfig?;
+    /** Track in-flight requests by href so each can be cancelled independently. */
+    private controllers;
+    constructor(requestConfig?: RequestConfig | undefined);
+    get(link: Link): Promise<Resource>;
+    getByHref(href: string): Promise<Resource>;
+    private fetchByHref;
+    cancel(href?: string): void;
+    destroy(): void;
+}

package/dist/types/fetcher/ReadError.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Typed errors for the Fetcher / Resource system.
+ *
+ * Every Fetcher implementation throws a ReadError subclass instead of
+ * a generic Error. Callers that need to distinguish failure reasons
+ * check `error.type`. Callers that don't just catch ReadError.
+ *
+ * Types:
+ * - `access` — the resource couldn't be reached (HTTP 4xx/5xx,
+ *   missing ZIP entry, network failure)
+ * - `decoding` — the resource was reached but its content is
+ *   invalid or corrupt (bad XML, unexpected format)
+ * - `cancelled` — the request was aborted (navigated away,
+ *   AbortController.abort())
+ */
+export type ReadErrorType = "access" | "decoding" | "cancelled";
+export declare class ReadError extends Error {
+    readonly type: ReadErrorType;
+    readonly href?: string;
+    readonly statusCode?: number;
+    readonly cause?: Error;
+    constructor(opts: {
+        type: ReadErrorType;
+        message: string;
+        href?: string;
+        statusCode?: number;
+        cause?: Error;
+    });
+    /** Resource not found or unreachable. */
+    static access(href: string, message: string, statusCode?: number): ReadError;
+    /** Content is corrupt or can't be decoded. */
+    static decoding(href: string, message: string, cause?: Error): ReadError;
+    /** Request was cancelled. */
+    static cancelled(href: string): ReadError;
+}

package/dist/types/fetcher/TransformingFetcher.d.ts

@@ -0,0 +1,38 @@
+import type { Link } from "../model/v3";
+import type { Fetcher, Resource } from "./Fetcher";
+/**
+ * A transform function applied to resources in the Fetcher chain.
+ *
+ * Receives a Resource and returns a (possibly modified) Resource.
+ * Return the original resource unchanged to pass it through.
+ *
+ * Transforms run after the inner Fetcher returns the resource,
+ * so the content is already fetched/decoded when the transform sees it.
+ */
+export type ResourceTransform = (resource: Resource) => Resource | Promise<Resource>;
+/**
+ * Fetcher that applies one or more transforms to resources.
+ *
+ * Wraps an inner Fetcher and passes every returned Resource through
+ * a list of transform functions. Transforms run in order — the output
+ * of one is the input of the next.
+ *
+ * Used for:
+ * - Font deobfuscation (IDPF/Adobe XOR on encrypted font bytes)
+ * - Future: LCP content key decryption, accessibility transforms
+ *
+ * Chain position:
+ *   CacheFetcher → ContentFetcher → TransformingFetcher → HttpFetcher/ZipFetcher
+ *
+ * The CacheFetcher caches the TRANSFORMED result, so transforms
+ * only run once per resource.
+ */
+export declare class TransformingFetcher implements Fetcher {
+    private readonly inner;
+    private readonly transforms;
+    constructor(inner: Fetcher, ...transforms: ResourceTransform[]);
+    get(link: Link): Promise<Resource>;
+    getByHref(href: string): Promise<Resource>;
+    cancel(href: string): void;
+    destroy(): void;
+}

package/dist/types/fetcher/ZipContainer.d.ts

@@ -0,0 +1,16 @@
+import type { Container } from "./Container";
+/**
+ * Container backed by a ZIP archive (EPUB, CBZ, etc.).
+ *
+ * Parses the ZIP on construction and provides read-only access to
+ * entries by path. All paths are as stored in the ZIP — no
+ * basePath resolution happens here (that's the Fetcher's job).
+ */
+export declare class ZipContainer implements Container {
+    private data;
+    constructor(input: ArrayBuffer | Uint8Array);
+    entries(): string[];
+    get(path: string): Uint8Array | undefined;
+    has(path: string): boolean;
+    destroy(): void;
+}

package/dist/types/fetcher/ZipFetcher.d.ts

@@ -0,0 +1,51 @@
+import type { Link } from "../model/v3";
+import type { Fetcher, Resource } from "./Fetcher";
+import type { Container } from "./Container";
+import type { EncryptionInfo } from "./FontDeobfuscator";
+/**
+ * Fetcher that reads resources from a Container (ZIP archive, etc.).
+ *
+ * Wraps a Container and builds Resource objects from its raw bytes.
+ * The Container owns the data; the ZipFetcher handles path resolution,
+ * media type guessing, and text decoding.
+ *
+ * Accepts raw ZIP bytes (creates a ZipContainer internally) or a
+ * pre-built Container for reuse across Fetchers.
+ *
+ * Used by:
+ * - D2Reader.load({ epub: file }) — opens an .epub file directly
+ * - DiViNaNavigator (3.11) — opens CBZ comic/manga archives
+ */
+export declare class ZipFetcher implements Fetcher {
+    readonly container: Container;
+    private basePath;
+    private encryptionMap?;
+    /**
+     * Update the basePath after construction. Used when the identifier
+     * is extracted from the ZIP content and incorporated into the path.
+     */
+    setBasePath(basePath: string): void;
+    /**
+     * Set encryption info so Resources carry encryption metadata
+     * in their `properties.encrypted` field. The TransformingFetcher
+     * reads this to know which resources need deobfuscation.
+     */
+    setEncryptionMap(map: Map<string, EncryptionInfo>): void;
+    constructor(source: ArrayBuffer | Uint8Array | Container, basePath?: string);
+    get(link: Link): Promise<Resource>;
+    getByHref(href: string): Promise<Resource>;
+    has(link: Link): Promise<boolean>;
+    /** List all file paths in the container. */
+    list(): string[];
+    /** Read a specific entry as raw bytes. */
+    getBytes(path: string): Uint8Array | undefined;
+    destroy(): void;
+    /**
+     * Resolve an href to a container entry path.
+     * Strips the basePath prefix, query strings, fragments, and
+     * leading slashes.
+     */
+    private resolvePath;
+    /** @deprecated Use `guessMediaType` from `./mediaType` instead. */
+    static guessMediaType(path: string): string;
+}

package/dist/types/fetcher/mediaType.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Guess media type from a file path's extension.
+ * Covers types commonly found in EPUB, CBZ, and web publications.
+ */
+export declare function guessMediaType(path: string): string;

package/dist/types/fetcher/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Extends RequestInit with reader-specific options.
+ *
+ * Passed to HttpFetcher and through the Fetcher chain.
+ * `encoded` signals that the server returns base64-encoded content
+ * (used by some Readium-compatible streamers).
+ */
+export interface RequestConfig extends RequestInit {
+    encoded?: boolean;
+}
+/**
+ * Integrator-provided content callback.
+ *
+ * Called by ContentFetcher for each resource request. If the integrator
+ * returns content (string), it's used directly. If it returns undefined,
+ * the request falls through to the inner Fetcher (typically HttpFetcher).
+ *
+ * Used for DRM decryption, custom content sources, content transformation.
+ */
+export type GetContent = (href: string) => Promise<string | undefined>;
+/**
+ * Callback to get the byte length of a resource.
+ *
+ * Used by Publication.autoGeneratePositions() to calculate
+ * reading positions from content size.
+ */
+export type GetContentBytesLength = (href: string, requestConfig?: RequestConfig) => Promise<number>;

package/dist/types/index.d.ts

@@ -18,7 +18,24 @@ export { ModuleRegistry } from "./modules/ModuleRegistry";
 export { ModuleAccessors } from "./modules/ModuleAccessors";
 export type { IBookmarkModule, ISearchModule, IAnnotationModule, IHistoryModule, SearchOptions, } from "./modules/interfaces";
 export { getPageFromLocations } from "./model/v3";
-export type { ReaderConfig, ReaderRights, NavigatorAPI, IFrameAttributes, Injectable, RequestConfig, SampleRead, PublicationServices, InitialAnnotations, EpubNavigatorConfig, IFrameNavigatorConfig, } from "./navigator/EpubNavigator";
+export type { Fetcher, Resource } from "./fetcher/Fetcher";
+export type { Container } from "./fetcher/Container";
+export type { RequestConfig, GetContent, GetContentBytesLength, } from "./fetcher/types";
+export { ZipContainer } from "./fetcher/ZipContainer";
+export { ReadError } from "./fetcher/ReadError";
+export type { ReadErrorType } from "./fetcher/ReadError";
+export { HttpFetcher } from "./fetcher/HttpFetcher";
+export { ContentFetcher } from "./fetcher/ContentFetcher";
+export { CacheFetcher } from "./fetcher/CacheFetcher";
+export { ZipFetcher } from "./fetcher/ZipFetcher";
+export { EpubParser } from "./fetcher/EpubParser";
+export { BlobUrlManager } from "./fetcher/BlobUrlManager";
+export { guessMediaType } from "./fetcher/mediaType";
+export { TransformingFetcher } from "./fetcher/TransformingFetcher";
+export type { ResourceTransform } from "./fetcher/TransformingFetcher";
+export { parseEncryptionXml, deobfuscateIdpf, deobfuscateAdobe, createDeobfuscationTransform, } from "./fetcher/FontDeobfuscator";
+export type { EncryptionInfo } from "./fetcher/FontDeobfuscator";
+export type { ReaderConfig, ReaderRights, NavigatorAPI, IFrameAttributes, Injectable, SampleRead, PublicationServices, InitialAnnotations, EpubNavigatorConfig, IFrameNavigatorConfig, } from "./navigator/EpubNavigator";
 export type { IUserSettings, InitialUserSettings, } from "./model/user-settings/UserSettings";
 export type { UserSettingsIncrementable } from "./model/user-settings/UserProperties";
 export type { LocalStorageStoreConfig } from "./store/LocalStorageStore";