@ankhorage/expo-runtime 3.1.1 → 3.2.0

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.
+  }
+}

package/src/reader/epub/mediaTypes.ts

@@ -0,0 +1,16 @@
+export const HTML_MEDIA_TYPES = new Set(['application/xhtml+xml', 'text/html']);
+
+export function inferEpubMediaType(path: string): string {
+  const extension = path.split('.').pop()?.toLowerCase() ?? '';
+  if (extension === 'css') return 'text/css';
+  if (extension === 'gif') return 'image/gif';
+  if (extension === 'html') return 'text/html';
+  if (extension === 'jpeg' || extension === 'jpg') return 'image/jpeg';
+  if (extension === 'png') return 'image/png';
+  if (extension === 'svg') return 'image/svg+xml';
+  if (extension === 'ttf') return 'font/ttf';
+  if (extension === 'woff') return 'font/woff';
+  if (extension === 'woff2') return 'font/woff2';
+  if (extension === 'xhtml') return 'application/xhtml+xml';
+  return 'application/octet-stream';
+}

package/src/reader/epub/parseEpubPackage.test.ts

@@ -0,0 +1,116 @@
+import { DOMParser as XmlDomParser } from '@xmldom/xmldom';
+import { TextReader, Uint8ArrayWriter, ZipWriter } from '@zip.js/zip.js';
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+
+import { EpubArchive } from './EpubArchive';
+import { parseEpubPackage } from './parseEpubPackage';
+
+const browserDomParser = globalThis.DOMParser;
+
+beforeEach(() => {
+  globalThis.DOMParser = XmlDomParser as unknown as typeof DOMParser;
+});
+
+afterEach(() => {
+  globalThis.DOMParser = browserDomParser;
+});
+
+describe('parseEpubPackage deterministic EPUB fixtures', () => {
+  test('parses a reflowable EPUB 3 spine and resources', async () => {
+    const archive = await openFixture(
+      packageDocument({
+        metadata: '',
+        progression: 'default',
+        spineProperties: '',
+      }),
+    );
+    const parsed = await parseEpubPackage(archive, new AbortController().signal);
+
+    expect(parsed.fixedLayout).toBe(false);
+    expect(parsed.direction).toBe('ltr');
+    expect(parsed.readingOrder.map((item) => item.href)).toEqual([
+      'OPS/chapter-1.xhtml',
+      'OPS/chapter-2.xhtml',
+    ]);
+    expect(parsed.resources.map((item) => item.href)).toContain('OPS/nav.xhtml');
+    expect(parsed.tableOfContents).toEqual([
+      { href: 'OPS/chapter-1.xhtml#start', title: 'Chapter one' },
+    ]);
+    await archive.close();
+  });
+
+  test('preserves fixed-layout and RTL package metadata', async () => {
+    const archive = await openFixture(
+      packageDocument({
+        metadata: '<meta property="rendition:layout">pre-paginated</meta>',
+        progression: 'rtl',
+        spineProperties: 'properties="rendition:layout-pre-paginated"',
+      }),
+    );
+    const parsed = await parseEpubPackage(archive, new AbortController().signal);
+
+    expect(parsed.fixedLayout).toBe(true);
+    expect(parsed.direction).toBe('rtl');
+    await archive.close();
+  });
+
+  test('rejects encrypted publication resources as protected content', async () => {
+    const archive = await openFixture(packageDocument(), {
+      'META-INF/encryption.xml': '<?xml version="1.0"?><encryption><EncryptedData /></encryption>',
+    });
+
+    let error: unknown;
+    try {
+      await parseEpubPackage(archive, new AbortController().signal);
+    } catch (caught) {
+      error = caught;
+    }
+    expect(error).toMatchObject({ code: 'protected-document' });
+    await archive.close();
+  });
+});
+
+async function openFixture(
+  packageSource: string,
+  extraFiles: Readonly<Record<string, string>> = {},
+): Promise<EpubArchive> {
+  const writer = new ZipWriter(new Uint8ArrayWriter());
+  const files = {
+    mimetype: 'application/epub+zip',
+    'META-INF/container.xml':
+      '<?xml version="1.0"?><container><rootfiles><rootfile full-path="OPS/package.opf" /></rootfiles></container>',
+    'OPS/package.opf': packageSource,
+    'OPS/chapter-1.xhtml': '<html><body><h1>One</h1></body></html>',
+    'OPS/chapter-2.xhtml': '<html><body><h1>Two</h1></body></html>',
+    'OPS/nav.xhtml':
+      '<html xmlns:epub="http://www.idpf.org/2007/ops"><body><nav epub:type="toc"><a href="chapter-1.xhtml#start">Chapter one</a></nav></body></html>',
+    ...extraFiles,
+  };
+  for (const [path, content] of Object.entries(files)) {
+    await writer.add(path, new TextReader(content), { lastModDate: new Date(0) });
+  }
+  const bytes = await writer.close();
+  return EpubArchive.open(bytes, new AbortController().signal);
+}
+
+function packageDocument(
+  options: {
+    metadata?: string;
+    progression?: 'default' | 'rtl';
+    spineProperties?: string;
+  } = {},
+): string {
+  return `<?xml version="1.0"?>
+    <package version="3.0">
+      <metadata><title>Reader fixture</title><language>en</language>${options.metadata ?? ''}</metadata>
+      <manifest>
+        <item id="one" href="chapter-1.xhtml" media-type="application/xhtml+xml" />
+        <item id="two" href="chapter-2.xhtml" media-type="application/xhtml+xml" />
+        <item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav" />
+      </manifest>
+      <spine page-progression-direction="${options.progression ?? 'default'}">
+        <itemref idref="one" ${options.spineProperties ?? ''} />
+        <itemref idref="two" ${options.spineProperties ?? ''} />
+      </spine>
+    </package>`;
+}

package/src/reader/epub/parseEpubPackage.ts

@@ -0,0 +1,152 @@
+/* eslint-disable max-lines-per-function, complexity -- Package parsing validates one transactional document graph. */
+import { ReaderDocumentError } from '../ReaderDocumentError';
+import type { EpubArchive } from './EpubArchive';
+import { resolveArchivePath } from './path';
+
+interface EpubPackageItem {
+  readonly href: string;
+  readonly mediaType: string;
+  readonly properties: readonly string[];
+}
+
+export interface ParsedEpubPackage {
+  readonly direction: 'ltr' | 'rtl';
+  readonly fixedLayout: boolean;
+  readonly language?: string;
+  readonly packagePath: string;
+  readonly readingOrder: readonly EpubPackageItem[];
+  readonly resources: readonly EpubPackageItem[];
+  readonly tableOfContents: readonly { readonly href: string; readonly title: string }[];
+  readonly title: string;
+}
+
+export async function parseEpubPackage(
+  archive: EpubArchive,
+  signal: AbortSignal,
+): Promise<ParsedEpubPackage> {
+  const mimetype = (await archive.readText('mimetype', signal)).trim();
+  if (mimetype !== 'application/epub+zip') {
+    throw new ReaderDocumentError('invalid-document', 'The archive is not an EPUB document.');
+  }
+  if (archive.has('META-INF/encryption.xml')) {
+    const encryption = await archive.readText('META-INF/encryption.xml', signal);
+    if (
+      elementsByLocalName(parseXml(encryption, 'EPUB encryption metadata'), 'EncryptedData')
+        .length > 0
+    ) {
+      throw new ReaderDocumentError(
+        'protected-document',
+        'This EPUB uses content protection and cannot be opened.',
+      );
+    }
+  }
+
+  const container = parseXml(
+    await archive.readText('META-INF/container.xml', signal),
+    'EPUB container',
+  );
+  const [rootfile] = elementsByLocalName(container, 'rootfile');
+  const packagePathValue = rootfile?.getAttribute('full-path');
+  if (!packagePathValue) {
+    throw new ReaderDocumentError(
+      'invalid-document',
+      'The EPUB container has no package document.',
+    );
+  }
+  const packagePath = resolveArchivePath('', packagePathValue);
+  const packageDocument = parseXml(await archive.readText(packagePath, signal), 'EPUB package');
+
+  const manifestItems = new Map<string, EpubPackageItem>();
+  for (const item of elementsByLocalName(packageDocument, 'item')) {
+    const id = item.getAttribute('id');
+    const href = item.getAttribute('href');
+    const mediaType = item.getAttribute('media-type');
+    if (!id || !href || !mediaType) continue;
+    manifestItems.set(id, {
+      href: resolveArchivePath(packagePath, href),
+      mediaType,
+      properties: (item.getAttribute('properties') ?? '').split(/\s+/).filter(Boolean),
+    });
+  }
+
+  const [spine] = elementsByLocalName(packageDocument, 'spine');
+  const readingOrder = elementsByLocalName(spine ?? packageDocument, 'itemref')
+    .map((itemref) => manifestItems.get(itemref.getAttribute('idref') ?? ''))
+    .filter((item): item is EpubPackageItem => item !== undefined);
+  if (readingOrder.length === 0) {
+    throw new ReaderDocumentError('invalid-document', 'The EPUB package has no readable spine.');
+  }
+
+  const metadata =
+    elementsByLocalName(packageDocument, 'metadata')[0] ?? packageDocument.documentElement;
+  const title = elementText(metadata, 'title') ?? 'Untitled publication';
+  const language = elementText(metadata, 'language');
+  const fixedLayout =
+    elementsByLocalName(metadata, 'meta').some(
+      (element) =>
+        element.getAttribute('property') === 'rendition:layout' &&
+        element.textContent.trim() === 'pre-paginated',
+    ) || readingOrder.every((item) => item.properties.includes('rendition:layout-pre-paginated'));
+  const direction = spine?.getAttribute('page-progression-direction') === 'rtl' ? 'rtl' : 'ltr';
+  const readingPaths = new Set(readingOrder.map((item) => item.href));
+  const navigationItem = [...manifestItems.values()].find((item) =>
+    item.properties.includes('nav'),
+  );
+  const tableOfContents = navigationItem
+    ? await parseNavigationDocument(archive, navigationItem.href, signal)
+    : [];
+
+  return {
+    direction,
+    fixedLayout,
+    language,
+    packagePath,
+    readingOrder,
+    resources: [...manifestItems.values()].filter((item) => !readingPaths.has(item.href)),
+    tableOfContents,
+    title,
+  };
+}
+
+async function parseNavigationDocument(
+  archive: EpubArchive,
+  navigationPath: string,
+  signal: AbortSignal,
+): Promise<{ href: string; title: string }[]> {
+  const document = parseXml(await archive.readText(navigationPath, signal), 'EPUB navigation');
+  const navigation =
+    elementsByLocalName(document, 'nav').find((element) =>
+      (element.getAttribute('epub:type') ?? element.getAttribute('type') ?? '')
+        .split(/\s+/)
+        .includes('toc'),
+    ) ?? elementsByLocalName(document, 'nav')[0];
+  if (!navigation) return [];
+  return elementsByLocalName(navigation, 'a').flatMap((anchor) => {
+    const href = anchor.getAttribute('href');
+    const title = anchor.textContent.trim();
+    if (!href || !title) return [];
+    const [resourceReference, fragment] = href.split('#', 2);
+    const resourcePath = resolveArchivePath(navigationPath, resourceReference ?? '');
+    return [{ href: fragment ? `${resourcePath}#${fragment}` : resourcePath, title }];
+  });
+}
+
+function parseXml(source: string, label: string): XMLDocument {
+  const document = new DOMParser().parseFromString(source, 'application/xml');
+  if (elementsByLocalName(document, 'parsererror').length > 0) {
+    throw new ReaderDocumentError('invalid-document', `Invalid ${label}.`);
+  }
+  return document;
+}
+
+function elementsByLocalName(root: Document | Element, localName: string): Element[] {
+  return Array.from(root.getElementsByTagName('*')).filter(
+    (element) => element.localName === localName,
+  );
+}
+
+function elementText(root: Document | Element, localName: string): string | undefined {
+  const [element] = elementsByLocalName(root, localName);
+  const value = element?.textContent.trim();
+  return value === '' ? undefined : value;
+}