@ankhorage/expo-runtime 3.1.1 → 3.2.2

package/src/reader/drivers/EpubReaderDriver.ts

@@ -0,0 +1,309 @@
+/* eslint-disable max-lines-per-function, complexity -- EPUB assembly keeps archive cleanup transactional. */
+import { EpubNavigator, type EpubNavigatorListeners } from '@readium/navigator';
+import { Locator, Manifest, Publication } from '@readium/shared';
+
+import { EpubArchive } from '../epub/EpubArchive';
+import { EpubArchiveFetcher } from '../epub/EpubArchiveFetcher';
+import { HTML_MEDIA_TYPES, inferEpubMediaType } from '../epub/mediaTypes';
+import { type ParsedEpubPackage, parseEpubPackage } from '../epub/parseEpubPackage';
+import { sanitizeEpubDocument, sanitizeEpubStylesheet } from '../epub/sanitizeEpubDocument';
+import type { ReaderAppearance, ReaderDriver, ReaderDriverState } from '../types';
+
+export class EpubReaderDriver implements ReaderDriver {
+  readonly direction: 'ltr' | 'rtl';
+  readonly #archive: EpubArchive;
+  readonly #navigator: EpubNavigator;
+  readonly #objectUrls: string[];
+  readonly #onExternalLink: (url: string) => void;
+  readonly #onStateChange: (state: ReaderDriverState) => void;
+  readonly #publication: Publication;
+  readonly #fixedLayout: boolean;
+  #page = 1;
+  #suppressStateNotifications = false;
+
+  private constructor(args: {
+    archive: EpubArchive;
+    direction: 'ltr' | 'rtl';
+    fixedLayout: boolean;
+    navigator: EpubNavigator;
+    objectUrls: string[];
+    onExternalLink: (url: string) => void;
+    onStateChange: (state: ReaderDriverState) => void;
+    publication: Publication;
+  }) {
+    this.#archive = args.archive;
+    this.direction = args.direction;
+    this.#fixedLayout = args.fixedLayout;
+    this.#navigator = args.navigator;
+    this.#objectUrls = args.objectUrls;
+    this.#onExternalLink = args.onExternalLink;
+    this.#onStateChange = args.onStateChange;
+    this.#publication = args.publication;
+  }
+
+  static async create(args: {
+    appearance: ReaderAppearance;
+    bytes: Uint8Array;
+    container: HTMLElement;
+    initialLocation?: string;
+    onExternalLink: (url: string) => void;
+    onStateChange: (state: ReaderDriverState) => void;
+    signal: AbortSignal;
+  }): Promise<EpubReaderDriver> {
+    const archive = await EpubArchive.open(args.bytes, args.signal);
+    const objectUrls: string[] = [];
+    try {
+      const packageData = await parseEpubPackage(archive, args.signal);
+      const { publication, objectUrls: createdUrls } = await createPublication(
+        archive,
+        packageData,
+        args.signal,
+      );
+      objectUrls.push(...createdUrls);
+      const holder: { driver?: EpubReaderDriver } = {};
+      const listeners: EpubNavigatorListeners = {
+        frameLoaded: (window) =>
+          attachFrameLinkPolicy(window, (url) => {
+            if (holder.driver !== undefined) holder.driver.#onExternalLink(url);
+          }),
+        positionChanged: () => {
+          if (holder.driver !== undefined) holder.driver.#notifyState();
+        },
+        timelineItemChanged: () => {
+          if (holder.driver !== undefined) holder.driver.#notifyState();
+        },
+        tap: () => false,
+        click: () => false,
+        zoom: noop,
+        miscPointer: noop,
+        scroll: noop,
+        customEvent: noop,
+        handleLocator: () => false,
+        textSelected: noop,
+        contentProtection: noop,
+        contextMenu: noop,
+        peripheral: noop,
+      };
+      const initialPosition = parseInitialLocator(args.initialLocation);
+      const navigator = new EpubNavigator(
+        args.container,
+        publication,
+        listeners,
+        [],
+        initialPosition,
+        {
+          defaults: {},
+          preferences: resolvePreferences(args.appearance),
+          injectables: { allowedDomains: [], rules: [] },
+        },
+      );
+      const driver = new EpubReaderDriver({
+        archive,
+        direction: packageData.direction,
+        fixedLayout: packageData.fixedLayout,
+        navigator,
+        objectUrls,
+        onExternalLink: args.onExternalLink,
+        onStateChange: args.onStateChange,
+        publication,
+      });
+      holder.driver = driver;
+      await navigator.load();
+      driver.#notifyState();
+      return driver;
+    } catch (error) {
+      objectUrls.forEach((url) => URL.revokeObjectURL(url));
+      await archive.close();
+      throw error;
+    }
+  }
+
+  getState(): ReaderDriverState {
+    const locator = this.#navigator.currentLocator;
+    const spineIndex = Math.max(
+      0,
+      this.#publication.readingOrder.items.findIndex((link) => link.href === locator.href),
+    );
+    const progressionInResource = locator.locations.progression ?? 0;
+    const totalProgression =
+      locator.locations.totalProgression ??
+      (spineIndex + progressionInResource) / this.#publication.readingOrder.items.length;
+    if (this.#fixedLayout) this.#page = spineIndex + 1;
+    return {
+      canGoNext: this.#navigator.canGoForward,
+      canGoPrevious: this.#navigator.canGoBackward,
+      chapterId: locator.href,
+      chapterTitle: locator.title,
+      locator: JSON.stringify(locator.serialize()),
+      page: this.#page,
+      pageCount: this.#fixedLayout ? this.#publication.readingOrder.items.length : undefined,
+      progression: Math.max(0, Math.min(1, totalProgression)),
+    };
+  }
+
+  async goNext(_trigger: Parameters<ReaderDriver['goNext']>[0]): Promise<void> {
+    if (!this.#navigator.canGoForward) return;
+    this.#suppressStateNotifications = true;
+    try {
+      await navigate((done) => this.#navigator.goForward(shouldAnimateNavigation(), done));
+      if (!this.#fixedLayout) this.#page += 1;
+    } finally {
+      this.#suppressStateNotifications = false;
+    }
+  }
+
+  async goPrevious(_trigger: Parameters<ReaderDriver['goPrevious']>[0]): Promise<void> {
+    if (!this.#navigator.canGoBackward) return;
+    this.#suppressStateNotifications = true;
+    try {
+      await navigate((done) => this.#navigator.goBackward(shouldAnimateNavigation(), done));
+      if (!this.#fixedLayout) this.#page = Math.max(1, this.#page - 1);
+    } finally {
+      this.#suppressStateNotifications = false;
+    }
+  }
+
+  async destroy(): Promise<void> {
+    await this.#navigator.destroy();
+    await this.#archive.close();
+    this.#objectUrls.forEach((url) => URL.revokeObjectURL(url));
+  }
+
+  #notifyState(): void {
+    if (!this.#suppressStateNotifications) this.#onStateChange(this.getState());
+  }
+}
+
+async function createPublication(
+  archive: EpubArchive,
+  packageData: ParsedEpubPackage,
+  signal: AbortSignal,
+): Promise<{ publication: Publication; objectUrls: string[] }> {
+  const objectUrls: string[] = [];
+  const resourceUrls = new Map<string, string>();
+  const itemByPath = new Map(
+    [...packageData.readingOrder, ...packageData.resources].map((item) => [item.href, item]),
+  );
+
+  for (const path of archive.paths()) {
+    const mediaType = itemByPath.get(path)?.mediaType ?? inferEpubMediaType(path);
+    if (HTML_MEDIA_TYPES.has(mediaType) || mediaType === 'text/css') continue;
+    const resource = await archive.read(path, signal);
+    const resourceBuffer = resource.buffer.slice(
+      resource.byteOffset,
+      resource.byteOffset + resource.byteLength,
+    ) as ArrayBuffer;
+    const url = URL.createObjectURL(new Blob([resourceBuffer], { type: mediaType }));
+    objectUrls.push(url);
+    resourceUrls.set(path, url);
+  }
+
+  const overrides = new Map<string, Uint8Array>();
+  for (const path of archive.paths()) {
+    const mediaType = itemByPath.get(path)?.mediaType ?? inferEpubMediaType(path);
+    if (mediaType !== 'text/css') continue;
+    const css = sanitizeEpubStylesheet(await archive.readText(path, signal), path, (resourcePath) =>
+      resourceUrls.get(resourcePath),
+    );
+    const url = URL.createObjectURL(new Blob([css], { type: mediaType }));
+    objectUrls.push(url);
+    resourceUrls.set(path, url);
+    overrides.set(path, new TextEncoder().encode(css));
+  }
+  for (const [path, item] of itemByPath) {
+    if (!HTML_MEDIA_TYPES.has(item.mediaType)) continue;
+    const source = sanitizeEpubDocument(
+      await archive.readText(path, signal),
+      path,
+      (resourcePath) => resourceUrls.get(resourcePath),
+    );
+    overrides.set(path, new TextEncoder().encode(source));
+  }
+
+  const manifest = Manifest.deserialize({
+    metadata: {
+      conformsTo: ['https://readium.org/webpub-manifest/profiles/epub'],
+      language: packageData.language,
+      layout: packageData.fixedLayout ? 'fixed' : 'reflowable',
+      readingProgression: packageData.direction,
+      title: packageData.title,
+    },
+    links: [
+      {
+        href: 'https://reader.invalid/manifest.json',
+        rel: 'self',
+        type: 'application/webpub+json',
+      },
+    ],
+    readingOrder: packageData.readingOrder.map(toManifestLink),
+    resources: packageData.resources.map(toManifestLink),
+    toc: packageData.tableOfContents.map((item) => ({
+      href: item.href,
+      title: item.title,
+      type: 'application/xhtml+xml',
+    })),
+  });
+  if (manifest === undefined) throw new Error('Could not construct the EPUB publication manifest.');
+  const links = [...manifest.readingOrder.items, ...(manifest.resources?.items ?? [])];
+  return {
+    publication: new Publication({
+      fetcher: new EpubArchiveFetcher(archive, links, overrides),
+      manifest,
+    }),
+    objectUrls,
+  };
+}
+
+function toManifestLink(item: ParsedEpubPackage['readingOrder'][number]) {
+  return {
+    href: item.href,
+    type: item.mediaType,
+    properties:
+      item.properties.length === 0
+        ? undefined
+        : Object.fromEntries(item.properties.map((key) => [key, true])),
+  };
+}
+
+function resolvePreferences(appearance: ReaderAppearance) {
+  const dark = appearance.colorScheme === 'dark';
+  const sepia = appearance.colorScheme === 'sepia';
+  return {
+    backgroundColor: dark ? '#111111' : sepia ? '#f4ecd8' : '#ffffff',
+    fontSize: appearance.fontScale,
+    lineHeight: appearance.lineHeight,
+    textColor: dark ? '#f5f5f5' : sepia ? '#3f3527' : '#111111',
+  };
+}
+
+function parseInitialLocator(value: string | undefined): Locator | undefined {
+  if (!value) return undefined;
+  try {
+    return Locator.deserialize(JSON.parse(value));
+  } catch {
+    return undefined;
+  }
+}
+
+function attachFrameLinkPolicy(window: Window, onExternalLink: (url: string) => void): void {
+  window.document.addEventListener('click', (event) => {
+    const target = event.target instanceof Element ? event.target.closest('a') : null;
+    const externalUrl = target?.getAttribute('data-reader-external-href');
+    if (!externalUrl) return;
+    event.preventDefault();
+    event.stopPropagation();
+    onExternalLink(externalUrl);
+  });
+}
+
+function navigate(start: (done: (ok: boolean) => void) => void): Promise<void> {
+  return new Promise((resolve) => start(() => resolve()));
+}
+
+function shouldAnimateNavigation(): boolean {
+  return !window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+}
+
+function noop(): void {
+  // Readium requires a complete listener object; these events are outside the reader contract.
+}

package/src/reader/drivers/PdfReaderDriver.ts

@@ -0,0 +1,253 @@
+import {
+  getDocument,
+  InvalidPDFException,
+  PasswordException,
+  type PDFDocumentLoadingTask,
+  type PDFDocumentProxy,
+  PDFWorker,
+  RenderingCancelledException,
+  type RenderTask,
+  TextLayer,
+} from 'pdfjs-dist';
+
+import { ReaderDocumentError } from '../ReaderDocumentError';
+import type { ReaderDriver, ReaderDriverState } from '../types';
+
+export class PdfReaderDriver implements ReaderDriver {
+  readonly direction = 'ltr' as const;
+  readonly #container: HTMLElement;
+  readonly #document: PDFDocumentProxy;
+  readonly #loadingTask: PDFDocumentLoadingTask;
+  readonly #onExternalLink: (url: string) => void;
+  readonly #onRenderError: (error: unknown) => void;
+  readonly #worker: PDFWorker;
+  #page: number;
+  #renderTask?: RenderTask;
+  #resizeFrame?: number;
+  #resizeObserver?: ResizeObserver;
+  #textLayer?: TextLayer;
+
+  private constructor(args: {
+    container: HTMLElement;
+    document: PDFDocumentProxy;
+    initialPage: number;
+    loadingTask: PDFDocumentLoadingTask;
+    onExternalLink: (url: string) => void;
+    onRenderError: (error: unknown) => void;
+    worker: PDFWorker;
+  }) {
+    this.#container = args.container;
+    this.#document = args.document;
+    this.#loadingTask = args.loadingTask;
+    this.#onExternalLink = args.onExternalLink;
+    this.#onRenderError = args.onRenderError;
+    this.#worker = args.worker;
+    this.#page = args.initialPage;
+  }
+
+  static async create(args: {
+    bytes: Uint8Array;
+    container: HTMLElement;
+    initialLocation?: string;
+    onExternalLink: (url: string) => void;
+    onRenderError: (error: unknown) => void;
+  }): Promise<PdfReaderDriver> {
+    const worker = createPdfWorker();
+    const loadingTask = getDocument({
+      data: args.bytes,
+      stopAtErrors: true,
+      worker,
+    });
+    try {
+      const document = await loadingTask.promise;
+      const driver = new PdfReaderDriver({
+        container: args.container,
+        document,
+        initialPage: resolveInitialPage(args.initialLocation, document.numPages),
+        loadingTask,
+        onExternalLink: args.onExternalLink,
+        onRenderError: args.onRenderError,
+        worker,
+      });
+      await driver.#renderPage();
+      driver.#observeResize();
+      return driver;
+    } catch (error) {
+      await loadingTask.destroy();
+      worker.destroy();
+      if (error instanceof PasswordException) {
+        throw new ReaderDocumentError(
+          'protected-document',
+          'This PDF is password protected and cannot be opened.',
+        );
+      }
+      if (error instanceof InvalidPDFException) {
+        throw new ReaderDocumentError('invalid-document', 'The PDF document is invalid.');
+      }
+      throw error;
+    }
+  }
+
+  getState(): ReaderDriverState {
+    return {
+      canGoNext: this.#page < this.#document.numPages,
+      canGoPrevious: this.#page > 1,
+      locator: `page=${this.#page}`,
+      page: this.#page,
+      pageCount: this.#document.numPages,
+      progression:
+        this.#document.numPages <= 1 ? 1 : (this.#page - 1) / (this.#document.numPages - 1),
+    };
+  }
+
+  async goNext(): Promise<void> {
+    if (this.#page >= this.#document.numPages) return;
+    this.#page += 1;
+    await this.#renderPage();
+  }
+
+  async goPrevious(): Promise<void> {
+    if (this.#page <= 1) return;
+    this.#page -= 1;
+    await this.#renderPage();
+  }
+
+  async destroy(): Promise<void> {
+    this.#renderTask?.cancel();
+    this.#resizeObserver?.disconnect();
+    if (this.#resizeFrame !== undefined) cancelAnimationFrame(this.#resizeFrame);
+    this.#textLayer?.cancel();
+    TextLayer.cleanup();
+    await this.#loadingTask.destroy();
+    this.#worker.destroy();
+    this.#container.replaceChildren();
+  }
+
+  async #renderPage(): Promise<void> {
+    this.#renderTask?.cancel();
+    this.#textLayer?.cancel();
+    const page = await this.#document.getPage(this.#page);
+    const baseViewport = page.getViewport({ scale: 1 });
+    const availableWidth = Math.max(1, this.#container.clientWidth);
+    const viewport = page.getViewport({ scale: availableWidth / baseViewport.width });
+    const pageElement = document.createElement('div');
+    const canvas = document.createElement('canvas');
+    const textContainer = document.createElement('div');
+    const linkContainer = document.createElement('div');
+    const outputScale = window.devicePixelRatio || 1;
+
+    pageElement.className = 'reader-pdf-page';
+    pageElement.style.setProperty('--scale-factor', String(viewport.scale));
+    pageElement.style.width = `${viewport.width}px`;
+    pageElement.style.height = `${viewport.height}px`;
+    canvas.width = Math.floor(viewport.width * outputScale);
+    canvas.height = Math.floor(viewport.height * outputScale);
+    canvas.style.width = `${viewport.width}px`;
+    canvas.style.height = `${viewport.height}px`;
+    textContainer.className = 'reader-pdf-text-layer';
+    textContainer.style.width = `${viewport.width}px`;
+    textContainer.style.height = `${viewport.height}px`;
+    linkContainer.className = 'reader-pdf-link-layer';
+    pageElement.append(canvas, textContainer, linkContainer);
+    this.#container.replaceChildren(pageElement);
+
+    const context = canvas.getContext('2d');
+    if (context === null) throw new Error('The PDF canvas context is unavailable.');
+    this.#renderTask = page.render({
+      canvas,
+      canvasContext: context,
+      transform: outputScale === 1 ? undefined : [outputScale, 0, 0, outputScale, 0, 0],
+      viewport,
+    });
+    this.#textLayer = new TextLayer({
+      container: textContainer,
+      textContentSource: page.streamTextContent(),
+      viewport,
+    });
+    await Promise.all([this.#renderTask.promise, this.#textLayer.render()]);
+    await renderExternalLinks(page, viewport, linkContainer, this.#onExternalLink);
+  }
+
+  #observeResize(): void {
+    let previousWidth = this.#container.clientWidth;
+    this.#resizeObserver = new ResizeObserver(() => {
+      const width = this.#container.clientWidth;
+      if (width === previousWidth) return;
+      previousWidth = width;
+      if (this.#resizeFrame !== undefined) cancelAnimationFrame(this.#resizeFrame);
+      this.#resizeFrame = requestAnimationFrame(() => {
+        void this.#renderPage().catch((error: unknown) => {
+          if (!(error instanceof RenderingCancelledException)) this.#onRenderError(error);
+        });
+      });
+    });
+    this.#resizeObserver.observe(this.#container);
+  }
+}
+
+function createPdfWorker(): PDFWorker {
+  const port = new Worker(new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url), {
+    type: 'module',
+  });
+  return PDFWorker.create({ port });
+}
+
+async function renderExternalLinks(
+  page: Awaited<ReturnType<PDFDocumentProxy['getPage']>>,
+  viewport: PdfViewport,
+  container: HTMLElement,
+  onExternalLink: (url: string) => void,
+): Promise<void> {
+  const annotations: unknown = await page.getAnnotations({ intent: 'display' });
+  if (!Array.isArray(annotations)) return;
+  for (const annotation of annotations as unknown[]) {
+    if (!isExternalPdfLink(annotation)) continue;
+    const [left, top] = viewport.convertToViewportPoint(annotation.rect[0], annotation.rect[1]) as [
+      number,
+      number,
+    ];
+    const [right, bottom] = viewport.convertToViewportPoint(
+      annotation.rect[2],
+      annotation.rect[3],
+    ) as [number, number];
+    const link = document.createElement('a');
+    link.setAttribute('aria-label', annotation.titleObj?.str ?? annotation.url);
+    link.href = '#';
+    link.style.inset = `${Math.min(bottom, top)}px auto auto ${Math.min(left, right)}px`;
+    link.style.width = `${Math.abs(right - left)}px`;
+    link.style.height = `${Math.abs(top - bottom)}px`;
+    link.addEventListener('click', (event) => {
+      event.preventDefault();
+      onExternalLink(annotation.url);
+    });
+    container.append(link);
+  }
+}
+
+interface PdfViewport {
+  convertToViewportPoint(x: number, y: number): number[];
+}
+
+function isExternalPdfLink(annotation: unknown): annotation is Record<string, unknown> & {
+  rect: [number, number, number, number];
+  titleObj?: { str?: string };
+  url: string;
+} {
+  return (
+    typeof annotation === 'object' &&
+    annotation !== null &&
+    'url' in annotation &&
+    'rect' in annotation &&
+    typeof annotation.url === 'string' &&
+    /^(?:https?:|mailto:|tel:)/i.test(annotation.url) &&
+    Array.isArray(annotation.rect) &&
+    annotation.rect.length === 4 &&
+    annotation.rect.every((value) => typeof value === 'number')
+  );
+}
+
+function resolveInitialPage(location: string | undefined, pageCount: number): number {
+  const match = /^page=(\d+)$/.exec(location ?? '');
+  const page = Number(match?.[1] ?? 1);
+  return Math.max(1, Math.min(pageCount, Number.isSafeInteger(page) ? page : 1));
+}

package/src/reader/epub/EpubArchive.ts

@@ -0,0 +1,83 @@
+import {
+  type Entry,
+  type FileEntry,
+  Uint8ArrayReader,
+  Uint8ArrayWriter,
+  ZipReader,
+} from '@zip.js/zip.js';
+
+import { ReaderDocumentError } from '../ReaderDocumentError';
+import { validateEpubArchiveEntriesAsync } from '../validateEpubArchiveEntriesAsync';
+import { normalizeArchivePath } from './path';
+
+export class EpubArchive {
+  readonly #entries: Map<string, FileEntry>;
+  readonly #reader: ZipReader<Uint8Array>;
+
+  private constructor(reader: ZipReader<Uint8Array>, entries: readonly Entry[]) {
+    this.#reader = reader;
+    this.#entries = createEntryMap(entries);
+  }
+
+  static async open(bytes: Uint8Array, signal: AbortSignal): Promise<EpubArchive> {
+    const reader = new ZipReader(new Uint8ArrayReader(bytes), { strictness: 'strict' });
+    try {
+      const entries = await reader.getEntries({ strictness: 'strict' });
+      await validateEpubArchiveEntriesAsync(entries, signal);
+      if (entries.some((entry) => !entry.directory && entry.encrypted)) {
+        throw new ReaderDocumentError(
+          'protected-document',
+          'This EPUB uses content protection and cannot be opened.',
+        );
+      }
+      return new EpubArchive(reader, entries);
+    } catch (error) {
+      await reader.close();
+      throw error;
+    }
+  }
+
+  paths(): readonly string[] {
+    return [...this.#entries.keys()];
+  }
+
+  has(path: string): boolean {
+    return this.#entries.has(normalizeArchivePath(path));
+  }
+
+  async read(path: string, signal?: AbortSignal): Promise<Uint8Array> {
+    const normalizedPath = normalizeArchivePath(path);
+    const entry = this.#entries.get(normalizedPath);
+    if (entry === undefined) throw new Error(`Missing EPUB resource: ${normalizedPath}`);
+    return entry.getData(new Uint8ArrayWriter(), {
+      checkCrc32: true,
+      checkOverlappingEntry: true,
+      signal,
+      strictness: 'strict',
+    });
+  }
+
+  async readText(path: string, signal?: AbortSignal): Promise<string> {
+    return new TextDecoder().decode(await this.read(path, signal));
+  }
+
+  async close(): Promise<void> {
+    await this.#reader.close();
+  }
+}
+
+function createEntryMap(entries: readonly Entry[]): Map<string, FileEntry> {
+  const files = new Map<string, FileEntry>();
+  for (const entry of entries) {
+    if (entry.directory) continue;
+    const normalizedPath = normalizeArchivePath(entry.filename);
+    if (files.has(normalizedPath)) {
+      throw new ReaderDocumentError(
+        'invalid-document',
+        `The EPUB contains duplicate resource path "${normalizedPath}".`,
+      );
+    }
+    files.set(normalizedPath, entry);
+  }
+  return files;
+}

package/src/reader/epub/EpubArchiveFetcher.ts

@@ -0,0 +1,58 @@
+import type { Link } from '@readium/shared';
+import { type Fetcher, Resource } from '@readium/shared';
+
+import type { EpubArchive } from './EpubArchive';
+
+export class EpubArchiveFetcher implements Fetcher {
+  readonly #archive: EpubArchive;
+  readonly #links: Link[];
+  readonly #overrides: ReadonlyMap<string, Uint8Array>;
+
+  constructor(
+    archive: EpubArchive,
+    links: readonly Link[],
+    overrides: ReadonlyMap<string, Uint8Array>,
+  ) {
+    this.#archive = archive;
+    this.#links = [...links];
+    this.#overrides = overrides;
+  }
+
+  links(): Link[] {
+    return [...this.#links];
+  }
+
+  get(link: Link): Resource {
+    return new EpubArchiveResource(this.#archive, link, this.#overrides.get(link.href));
+  }
+
+  close(): void {
+    void this.#archive.close();
+  }
+}
+
+class EpubArchiveResource extends Resource {
+  constructor(
+    readonly archive: EpubArchive,
+    readonly resourceLink: Link,
+    readonly override: Uint8Array | undefined,
+  ) {
+    super();
+  }
+
+  link(): Promise<Link> {
+    return Promise.resolve(this.resourceLink);
+  }
+
+  async length(): Promise<number | undefined> {
+    return (this.override ?? (await this.archive.read(this.resourceLink.href))).byteLength;
+  }
+
+  async read(): Promise<Uint8Array | undefined> {
+    return this.override ?? this.archive.read(this.resourceLink.href);
+  }
+
+  close(): void {
+    // Archive lifetime is owned by the driver.
+  }
+}