npm - @ankhorage/expo-runtime - Versions diffs - 3.1.1 → 3.2.2 - Mend

@ankhorage/expo-runtime 3.1.1 → 3.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (121) hide show

package/CHANGELOG.md +24 -0
package/README.md +2 -1
package/dist/barcodeScanner.d.ts +2 -0
package/dist/barcodeScanner.d.ts.map +1 -0
package/dist/barcodeScanner.js +2 -0
package/dist/barcodeScanner.js.map +1 -0
package/dist/createExpoRuntimeRegistry.d.ts.map +1 -1
package/dist/createExpoRuntimeRegistry.js +5 -0
package/dist/createExpoRuntimeRegistry.js.map +1 -1
package/dist/expoRuntimePlanningMetadata.d.ts +9 -1
package/dist/expoRuntimePlanningMetadata.d.ts.map +1 -1
package/dist/expoRuntimePlanningMetadata.js +8 -0
package/dist/expoRuntimePlanningMetadata.js.map +1 -1
package/dist/generatedSources.d.ts +1 -0
package/dist/generatedSources.d.ts.map +1 -1
package/dist/generatedSources.js +9 -1
package/dist/generatedSources.js.map +1 -1
package/dist/index.d.ts +2 -1
package/dist/index.d.ts.map +1 -1
package/dist/index.js +2 -1
package/dist/index.js.map +1 -1
package/dist/planning.d.ts +1 -1
package/dist/planning.d.ts.map +1 -1
package/dist/planning.js +1 -1
package/dist/planning.js.map +1 -1
package/dist/reader/ExpoReaderSurfaceAdapter.d.ts +4 -0
package/dist/reader/ExpoReaderSurfaceAdapter.d.ts.map +1 -0
package/dist/reader/ExpoReaderSurfaceAdapter.js +102 -0
package/dist/reader/ExpoReaderSurfaceAdapter.js.map +1 -0
package/dist/reader/ReaderDocumentError.d.ts +6 -0
package/dist/reader/ReaderDocumentError.d.ts.map +1 -0
package/dist/reader/ReaderDocumentError.js +9 -0
package/dist/reader/ReaderDocumentError.js.map +1 -0
package/dist/reader/ReaderViewport.d.ts +4 -0
package/dist/reader/ReaderViewport.d.ts.map +1 -0
package/dist/reader/ReaderViewport.js +212 -0
package/dist/reader/ReaderViewport.js.map +1 -0
package/dist/reader/drivers/EpubReaderDriver.d.ts +20 -0
package/dist/reader/drivers/EpubReaderDriver.d.ts.map +1 -0
package/dist/reader/drivers/EpubReaderDriver.js +259 -0
package/dist/reader/drivers/EpubReaderDriver.js.map +1 -0
package/dist/reader/drivers/PdfReaderDriver.d.ts +18 -0
package/dist/reader/drivers/PdfReaderDriver.d.ts.map +1 -0
package/dist/reader/drivers/PdfReaderDriver.js +198 -0
package/dist/reader/drivers/PdfReaderDriver.js.map +1 -0
package/dist/reader/epub/EpubArchive.d.ts +11 -0
package/dist/reader/epub/EpubArchive.d.ts.map +1 -0
package/dist/reader/epub/EpubArchive.js +65 -0
package/dist/reader/epub/EpubArchive.js.map +1 -0
package/dist/reader/epub/EpubArchiveFetcher.d.ts +11 -0
package/dist/reader/epub/EpubArchiveFetcher.d.ts.map +1 -0
package/dist/reader/epub/EpubArchiveFetcher.js +44 -0
package/dist/reader/epub/EpubArchiveFetcher.js.map +1 -0
package/dist/reader/epub/mediaTypes.d.ts +3 -0
package/dist/reader/epub/mediaTypes.d.ts.map +1 -0
package/dist/reader/epub/mediaTypes.js +26 -0
package/dist/reader/epub/mediaTypes.js.map +1 -0
package/dist/reader/epub/parseEpubPackage.d.ts +22 -0
package/dist/reader/epub/parseEpubPackage.d.ts.map +1 -0
package/dist/reader/epub/parseEpubPackage.js +98 -0
package/dist/reader/epub/parseEpubPackage.js.map +1 -0
package/dist/reader/epub/path.d.ts +4 -0
package/dist/reader/epub/path.d.ts.map +1 -0
package/dist/reader/epub/path.js +28 -0
package/dist/reader/epub/path.js.map +1 -0
package/dist/reader/epub/sanitizeEpubDocument.d.ts +3 -0
package/dist/reader/epub/sanitizeEpubDocument.d.ts.map +1 -0
package/dist/reader/epub/sanitizeEpubDocument.js +90 -0
package/dist/reader/epub/sanitizeEpubDocument.js.map +1 -0
package/dist/reader/index.d.ts +2 -0
package/dist/reader/index.d.ts.map +1 -0
package/dist/reader/index.js +2 -0
package/dist/reader/index.js.map +1 -0
package/dist/reader/loadReaderSourceAsync.d.ts +2 -0
package/dist/reader/loadReaderSourceAsync.d.ts.map +1 -0
package/dist/reader/loadReaderSourceAsync.js +49 -0
package/dist/reader/loadReaderSourceAsync.js.map +1 -0
package/dist/reader/readerViewportPresentation.d.ts +4 -0
package/dist/reader/readerViewportPresentation.d.ts.map +1 -0
package/dist/reader/readerViewportPresentation.js +26 -0
package/dist/reader/readerViewportPresentation.js.map +1 -0
package/dist/reader/types.d.ts +57 -0
package/dist/reader/types.d.ts.map +1 -0
package/dist/reader/types.js +2 -0
package/dist/reader/types.js.map +1 -0
package/dist/reader/validateEpubArchiveEntriesAsync.d.ts +3 -0
package/dist/reader/validateEpubArchiveEntriesAsync.d.ts.map +1 -0
package/dist/reader/validateEpubArchiveEntriesAsync.js +48 -0
package/dist/reader/validateEpubArchiveEntriesAsync.js.map +1 -0
package/package.json +25 -4
package/src/adapterEntrypoints.test.ts +48 -0
package/src/barcodeScanner.ts +1 -0
package/src/createExpoRuntimeRegistry.test.tsx +9 -1
package/src/createExpoRuntimeRegistry.tsx +7 -1
package/src/expoRuntimePlanningMetadata.ts +9 -1
package/src/generatedSources.test.ts +11 -2
package/src/generatedSources.ts +11 -1
package/src/index.ts +5 -1
package/src/planning.ts +4 -1
package/src/reader/ExpoReaderSurfaceAdapter.tsx +170 -0
package/src/reader/ReaderDocumentError.ts +11 -0
package/src/reader/ReaderViewport.tsx +319 -0
package/src/reader/drivers/EpubReaderDriver.ts +309 -0
package/src/reader/drivers/PdfReaderDriver.ts +253 -0
package/src/reader/epub/EpubArchive.ts +83 -0
package/src/reader/epub/EpubArchiveFetcher.ts +58 -0
package/src/reader/epub/mediaTypes.ts +16 -0
package/src/reader/epub/parseEpubPackage.test.ts +116 -0
package/src/reader/epub/parseEpubPackage.ts +152 -0
package/src/reader/epub/path.test.ts +22 -0
package/src/reader/epub/path.ts +26 -0
package/src/reader/epub/sanitizeEpubDocument.ts +121 -0
package/src/reader/index.ts +1 -0
package/src/reader/loadReaderSourceAsync.test.ts +52 -0
package/src/reader/loadReaderSourceAsync.ts +59 -0
package/src/reader/readerViewportPresentation.ts +28 -0
package/src/reader/rendererPackages.test.ts +3 -1
package/src/reader/types.ts +61 -0
package/src/reader/validateEpubArchiveEntriesAsync.test.ts +142 -0
package/src/reader/validateEpubArchiveEntriesAsync.ts +73 -0
package/src/resolveExpoRuntimePlan.test.ts +36 -0

package/src/reader/epub/mediaTypes.ts ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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;
+}

package/src/reader/epub/path.test.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import { describe, expect, test } from 'bun:test';
+import { isExternalReference, normalizeArchivePath, resolveArchivePath } from './path';
+describe('EPUB archive paths', () => {
+  test('resolves package-relative resources without escaping the archive', () => {
+    expect(resolveArchivePath('OPS/package.opf', 'text/../images/cover.jpg')).toBe(
+      'OPS/images/cover.jpg',
+    );
+    expect(() => resolveArchivePath('', '../../outside')).toThrow('escapes the archive');
+  });
+  test('normalizes platform separators and encoded names', () => {
+    expect(normalizeArchivePath('OPS\\Text%20One.xhtml')).toBe('OPS/Text One.xhtml');
+  });
+  test('classifies active external URL schemes', () => {
+    expect(isExternalReference('https://example.test')).toBe(true);
+    expect(isExternalReference('javascript:alert(1)')).toBe(true);
+    expect(isExternalReference('../images/cover.png')).toBe(false);
+  });
+});

package/src/reader/epub/path.ts ADDED Viewed

@@ -0,0 +1,26 @@
+export function normalizeArchivePath(path: string): string {
+  const segments: string[] = [];
+  for (const segment of decodeURIComponent(path).replaceAll('\\', '/').split('/')) {
+    if (segment === '' || segment === '.') continue;
+    if (segment === '..') {
+      if (segments.length === 0) throw new Error(`EPUB resource escapes the archive: ${path}`);
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join('/');
+}
+export function resolveArchivePath(basePath: string, reference: string): string {
+  const cleanReference = reference.split('#', 1)[0]?.split('?', 1)[0] ?? '';
+  if (cleanReference.startsWith('/')) return normalizeArchivePath(cleanReference);
+  const baseDirectory = basePath.includes('/')
+    ? basePath.slice(0, basePath.lastIndexOf('/') + 1)
+    : '';
+  return normalizeArchivePath(`${baseDirectory}${cleanReference}`);
+}
+export function isExternalReference(reference: string): boolean {
+  return /^(?:https?:|mailto:|tel:|data:|javascript:|\/\/)/i.test(reference.trim());
+}

package/src/reader/epub/sanitizeEpubDocument.ts ADDED Viewed

@@ -0,0 +1,121 @@
+import { isExternalReference, resolveArchivePath } from './path';
+const REMOVED_ELEMENTS = 'script, form, iframe, frame, object, embed';
+const RESOURCE_ATTRIBUTES = ['src', 'poster', 'data'] as const;
+export function sanitizeEpubDocument(
+  source: string,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): string {
+  const document = new DOMParser().parseFromString(source, 'application/xhtml+xml');
+  if (document.querySelector('parsererror')) {
+    throw new Error(`Invalid EPUB XHTML resource: ${resourcePath}`);
+  }
+  document.querySelectorAll(REMOVED_ELEMENTS).forEach((element) => element.remove());
+  document
+    .querySelectorAll('meta[http-equiv]')
+    .forEach(
+      (element) =>
+        element.getAttribute('http-equiv')?.toLowerCase() === 'refresh' && element.remove(),
+    );
+  sanitizeElementAttributes(document, resourcePath, resolveResourceUrl);
+  rewriteDocumentResources(document, resourcePath, resolveResourceUrl);
+  rewriteDocumentLinks(document);
+  return new XMLSerializer().serializeToString(document);
+}
+function sanitizeElementAttributes(
+  document: XMLDocument,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): void {
+  for (const element of document.querySelectorAll('*')) {
+    for (const attribute of Array.from(element.attributes)) {
+      if (attribute.name.toLowerCase().startsWith('on')) element.removeAttribute(attribute.name);
+    }
+    const inlineStyle = element.getAttribute('style');
+    if (inlineStyle) {
+      element.setAttribute(
+        'style',
+        sanitizeEpubStylesheet(inlineStyle, resourcePath, resolveResourceUrl),
+      );
+    }
+    element.removeAttribute('srcset');
+  }
+  for (const style of document.querySelectorAll('style')) {
+    style.textContent = sanitizeEpubStylesheet(style.textContent, resourcePath, resolveResourceUrl);
+  }
+}
+function rewriteDocumentResources(
+  document: XMLDocument,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): void {
+  for (const attributeName of RESOURCE_ATTRIBUTES) {
+    for (const element of document.querySelectorAll(`[${attributeName}]`)) {
+      rewriteResourceAttribute(element, attributeName, resourcePath, resolveResourceUrl);
+    }
+  }
+  for (const link of document.querySelectorAll('link[href]')) {
+    rewriteResourceAttribute(link, 'href', resourcePath, resolveResourceUrl);
+  }
+}
+function rewriteDocumentLinks(document: XMLDocument): void {
+  for (const anchor of document.querySelectorAll('a[href]')) {
+    const href = anchor.getAttribute('href')?.trim();
+    if (!href) continue;
+    if (/^(?:https?:|mailto:|tel:|\/\/)/i.test(href)) {
+      anchor.setAttribute('data-reader-external-href', href);
+      anchor.removeAttribute('href');
+    } else if (isExternalReference(href)) {
+      anchor.removeAttribute('href');
+    }
+  }
+}
+export function sanitizeEpubStylesheet(
+  source: string,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): string {
+  const withoutImports = source.replaceAll(/@import\s+(?:url\([^)]*\)|[^;]+);?/gi, '');
+  return withoutImports.replaceAll(
+    /url\(\s*(['"]?)([^)'"\s]+)\1\s*\)/gi,
+    (match, _quote, value: string) => {
+      if (isExternalReference(value)) return 'url(about:blank)';
+      try {
+        return `url("${resolveResourceUrl(resolveArchivePath(resourcePath, value)) ?? 'about:blank'}")`;
+      } catch {
+        return 'url(about:blank)';
+      }
+    },
+  );
+}
+function rewriteResourceAttribute(
+  element: Element,
+  attributeName: string,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): void {
+  const value = element.getAttribute(attributeName)?.trim();
+  if (!value) return;
+  if (isExternalReference(value)) {
+    element.removeAttribute(attributeName);
+    return;
+  }
+  try {
+    const resolved = resolveResourceUrl(resolveArchivePath(resourcePath, value));
+    if (resolved === undefined) element.removeAttribute(attributeName);
+    else element.setAttribute(attributeName, resolved);
+  } catch {
+    element.removeAttribute(attributeName);
+  }
+}

package/src/reader/index.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { ExpoReaderSurfaceAdapter } from './ExpoReaderSurfaceAdapter';

package/src/reader/loadReaderSourceAsync.test.ts ADDED Viewed

@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test';
+import { loadReaderSourceAsync } from './loadReaderSourceAsync';
+const originalFetch = globalThis.fetch;
+describe('loadReaderSourceAsync', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    mock.restore();
+  });
+  test('loads a bounded source without forwarding credentials', async () => {
+    const requests: RequestInit[] = [];
+    globalThis.fetch = mock((_url: string | URL | Request, init?: RequestInit) => {
+      requests.push(init ?? {});
+      return Promise.resolve(new Response(new Uint8Array([1, 2, 3]), { status: 200 }));
+    }) as typeof fetch;
+    const controller = new AbortController();
+    expect(await loadReaderSourceAsync('https://example.test/book.pdf', controller.signal)).toEqual(
+      new Uint8Array([1, 2, 3]),
+    );
+    expect(requests[0]?.credentials).toBe('omit');
+    expect(requests[0]?.signal).toBe(controller.signal);
+  });
+  test('rejects unsuccessful responses before reading their body', () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response('missing', { status: 404 })),
+    ) as typeof fetch;
+    expect(
+      loadReaderSourceAsync('https://example.test/missing.epub', new AbortController().signal),
+    ).rejects.toThrow('HTTP 404');
+  });
+  test('rejects a declared body larger than the reader download budget', () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(null, {
+          headers: { 'content-length': String(256 * 1024 * 1024 + 1) },
+          status: 200,
+        }),
+      ),
+    ) as typeof fetch;
+    expect(
+      loadReaderSourceAsync('https://example.test/huge.epub', new AbortController().signal),
+    ).rejects.toThrow('download limit');
+  });
+});

package/src/reader/loadReaderSourceAsync.ts ADDED Viewed

@@ -0,0 +1,59 @@
+const MAX_READER_SOURCE_BYTES = 256 * 1024 * 1024;
+export async function loadReaderSourceAsync(
+  sourceUri: string,
+  signal: AbortSignal,
+): Promise<Uint8Array> {
+  const response = await fetch(sourceUri, {
+    credentials: 'omit',
+    signal,
+  });
+  if (!response.ok) {
+    throw new Error(`Reader source request failed with HTTP ${response.status}.`);
+  }
+  const declaredLength = Number(response.headers.get('content-length'));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_READER_SOURCE_BYTES) {
+    throw new Error(`Reader source exceeds the ${MAX_READER_SOURCE_BYTES}-byte download limit.`);
+  }
+  if (response.body === null) {
+    return validateSourceSize(new Uint8Array(await response.arrayBuffer()));
+  }
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let byteLength = 0;
+  try {
+    for (;;) {
+      const result = await reader.read();
+      if (result.done) break;
+      byteLength += result.value.byteLength;
+      if (byteLength > MAX_READER_SOURCE_BYTES) {
+        throw new Error(
+          `Reader source exceeds the ${MAX_READER_SOURCE_BYTES}-byte download limit.`,
+        );
+      }
+      chunks.push(result.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function validateSourceSize(bytes: Uint8Array): Uint8Array {
+  if (bytes.byteLength > MAX_READER_SOURCE_BYTES) {
+    throw new Error(`Reader source exceeds the ${MAX_READER_SOURCE_BYTES}-byte download limit.`);
+  }
+  return bytes;
+}

package/src/reader/readerViewportPresentation.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import type { ReaderViewportState } from './types';
+export const LOADING_STATE: ReaderViewportState = {
+  canGoNext: false,
+  canGoPrevious: false,
+  page: 1,
+  progress: 0,
+  status: 'loading',
+};
+export const READER_STYLES = `
+  :root, body, #root { height: 100%; margin: 0; overflow: hidden; }
+  * { box-sizing: border-box; }
+  .reader-root { background: #fff; color: #111; height: 100%; outline: none; overflow: hidden; touch-action: pan-y; width: 100%; }
+  .reader-dark { background: #111; color: #f5f5f5; }
+  .reader-sepia { background: #f4ecd8; color: #3f3527; }
+  .reader-content { height: 100%; overflow: auto; position: relative; width: 100%; }
+  .reader-content > div:not(.reader-pdf-page) { height: 100%; width: 100%; }
+  .reader-pdf-page { --user-unit: 1; --total-scale-factor: calc(var(--scale-factor) * var(--user-unit)); margin: 0 auto; position: relative; }
+  .reader-pdf-page canvas { display: block; position: absolute; inset: 0; }
+  .reader-pdf-text-layer { --min-font-size: 1; --text-scale-factor: calc(var(--total-scale-factor) * var(--min-font-size)); --min-font-size-inv: calc(1 / var(--min-font-size)); inset: 0; line-height: 1; opacity: 1; overflow: hidden; position: absolute; text-align: initial; text-size-adjust: none; transform-origin: 0 0; }
+  .reader-pdf-text-layer span, .reader-pdf-text-layer br { color: transparent; cursor: text; position: absolute; transform-origin: 0 0; user-select: text; white-space: pre; }
+  .reader-pdf-text-layer > :not(.markedContent), .reader-pdf-text-layer .markedContent span:not(.markedContent) { --font-height: 0; --scale-x: 1; --rotate: 0deg; font-size: calc(var(--text-scale-factor) * var(--font-height)); transform: rotate(var(--rotate)) scaleX(var(--scale-x)) scale(var(--min-font-size-inv)); }
+  .reader-pdf-text-layer .markedContent { display: contents; }
+  .reader-pdf-text-layer ::selection { background: rgba(0, 100, 255, 0.35); }
+  .reader-pdf-link-layer { inset: 0; pointer-events: none; position: absolute; }
+  .reader-pdf-link-layer a { outline-offset: 2px; pointer-events: auto; position: absolute; }
+`;

package/src/reader/rendererPackages.test.ts CHANGED Viewed

@@ -2,12 +2,14 @@ import { describe, expect, test } from 'bun:test';
 describe('reader renderer package boundary', () => {
   test('provides the EPUB navigator and archive APIs required by the driver', async () => {
-    const [{ EpubNavigator }, { BlobReader, ZipReader }] = await Promise.all([
+    const [{ EpubNavigator }, { Publication }, { BlobReader, ZipReader }] = await Promise.all([
       import('@readium/navigator'),
+      import('@readium/shared'),
       import('@zip.js/zip.js'),
     ]);
     expect(EpubNavigator).toBeFunction();
+    expect(Publication).toBeFunction();
     expect(BlobReader).toBeFunction();
     expect(ZipReader).toBeFunction();
   });

package/src/reader/types.ts ADDED Viewed

@@ -0,0 +1,61 @@
+import type { ReaderErrorEvent, ReaderLocationChangeEvent } from '@ankhorage/zora';
+import type { DOMProps } from 'expo/dom';
+export interface ReaderAppearance {
+  readonly colorScheme: 'dark' | 'light' | 'sepia' | 'system';
+  readonly fontScale: number;
+  readonly lineHeight: number;
+}
+export interface ReaderCommand {
+  readonly id: number;
+  readonly sourceUri: string;
+  readonly type: 'next' | 'previous';
+}
+export interface ReaderViewportState {
+  readonly canGoNext: boolean;
+  readonly canGoPrevious: boolean;
+  readonly location?: ReaderLocationChangeEvent;
+  readonly page: number;
+  readonly pageCount?: number;
+  readonly progress: number;
+  readonly status: 'loading' | 'ready';
+}
+export interface ReaderViewportProps {
+  readonly appearance: ReaderAppearance;
+  readonly command?: ReaderCommand;
+  readonly format: 'epub' | 'pdf';
+  readonly initialLocation?: string;
+  readonly onError: (event: ReaderErrorEvent) => Promise<void>;
+  readonly onOpenExternalLink: (event: { readonly url: string }) => Promise<void>;
+  readonly onStateChange: (state: ReaderViewportState) => Promise<void>;
+  readonly sourceUri: string;
+  readonly dom?: DOMProps;
+}
+export interface ReaderDriverState {
+  readonly canGoNext: boolean;
+  readonly canGoPrevious: boolean;
+  readonly chapterId?: string;
+  readonly chapterTitle?: string;
+  readonly locator: string;
+  readonly page: number;
+  readonly pageCount?: number;
+  readonly progression: number;
+}
+export interface ReaderDriver {
+  readonly direction: 'ltr' | 'rtl';
+  destroy(): Promise<void>;
+  getState(): ReaderDriverState;
+  goNext(trigger: ReaderLocationChangeEvent['trigger']): Promise<void>;
+  goPrevious(trigger: ReaderLocationChangeEvent['trigger']): Promise<void>;
+}
+export interface ReaderTouchStart {
+  readonly interactive: boolean;
+  readonly x: number;
+  readonly y: number;
+}