@aseity/idocs-preview 0.0.0-stage → 0.2.0

package/dist/core/fonts.js

@@ -0,0 +1,135 @@
+export const CANVAS_TEXT_LANGUAGE = 'und';
+const GENERIC = new Set(['serif', 'sans-serif', 'monospace']);
+/**
+ * Word family → its look-alikes on Windows, macOS and Linux, ending in a
+ * generic family. Covers the default theme and common Word families.
+ */
+const SIMILAR = {
+    MiSans: ['MiSans', 'Microsoft YaHei', 'PingFang SC', 'Noto Sans CJK SC', 'sans-serif'],
+    'Noto Sans CJK SC': ['Noto Sans CJK SC', 'Microsoft YaHei', 'PingFang SC', 'sans-serif'],
+    'Noto Serif CJK SC': ['Noto Serif CJK SC', 'SimSun', 'Songti SC', 'serif'],
+    // Simplified Chinese
+    SimSun: ['SimSun', 'Songti SC', 'Noto Serif CJK SC', 'serif'],
+    SimHei: ['SimHei', 'Heiti SC', 'STHeiti', 'Noto Sans CJK SC', 'sans-serif'],
+    'Microsoft YaHei': ['Microsoft YaHei', 'PingFang SC', 'Noto Sans CJK SC', 'sans-serif'],
+    DengXian: ['DengXian', 'PingFang SC', 'Noto Sans CJK SC', 'sans-serif'],
+    FangSong: ['FangSong', 'STFangsong', 'FandolFang', 'Noto Serif CJK SC', 'serif'],
+    KaiTi: ['KaiTi', 'Kaiti SC', 'STKaiti', 'AR PL UKai CN', 'FandolKai', 'Noto Serif CJK SC', 'serif'],
+    // Traditional Chinese
+    PMingLiU: ['PMingLiU', 'Songti TC', 'Noto Serif CJK TC', 'serif'],
+    MingLiU: ['MingLiU', 'Songti TC', 'Noto Serif CJK TC', 'serif'],
+    'Microsoft JhengHei': ['Microsoft JhengHei', 'PingFang TC', 'Noto Sans CJK TC', 'sans-serif'],
+    // Japanese
+    'MS Gothic': ['MS Gothic', 'Hiragino Kaku Gothic ProN', 'Noto Sans CJK JP', 'Noto Sans CJK SC', 'sans-serif'],
+    // Latin
+    'Times New Roman': ['Times New Roman', 'Times', 'Liberation Serif', 'Tinos', 'serif'],
+    Arial: ['Arial', 'Helvetica', 'Liberation Sans', 'Arimo', 'sans-serif'],
+    Calibri: ['Calibri', 'Carlito', 'sans-serif'],
+    Consolas: ['Consolas', 'Menlo', 'Inconsolata', 'Liberation Mono', 'monospace'],
+    'Courier New': ['Courier New', 'Courier', 'Liberation Mono', 'Cousine', 'monospace'],
+    Cambria: ['Cambria', 'Caladea', 'serif'],
+    'Cambria Math': ['Cambria Math', 'STIX Two Math', 'serif'],
+    Aptos: ['Aptos', 'sans-serif'],
+    'Segoe UI': ['Segoe UI', 'Helvetica Neue', 'Noto Sans', 'sans-serif'],
+};
+/** Chinese names Word documents use for the families above. */
+const ALIASES = {
+    微软雅黑: 'Microsoft YaHei',
+    等线: 'DengXian',
+    宋体: 'SimSun',
+    黑体: 'SimHei',
+    仿宋: 'FangSong',
+    楷体: 'KaiTi',
+    新細明體: 'PMingLiU',
+    微軟正黑體: 'Microsoft JhengHei',
+    細明體: 'MingLiU',
+    'ＭＳ ゴシック': 'MS Gothic',
+};
+const BY_LOWER = new Map(Object.keys(SIMILAR).map((name) => [name.toLowerCase(), name]));
+/** The Word family a declared name stands for, matched as Word does (case-insensitive). */
+function wordFamily(name) {
+    return BY_LOWER.get((ALIASES[name] ?? name).toLowerCase());
+}
+function roleGeneric(role) {
+    if (role === 'mono')
+        return 'monospace';
+    if (role === 'sans')
+        return 'sans-serif';
+    return 'serif';
+}
+/**
+ * The CSS font families to draw `run` with, most preferred first; the last is
+ * always a generic family. When layout measured the declared family itself,
+ * it leads, then the look-alikes of the Word family it names. When the
+ * selected family differs from the declared family, layout measured a fallback face:
+ * that face and its look-alikes lead, so glyphs are drawn as wide as they
+ * were placed, and the declared family only covers characters they lack.
+ */
+export function fontChain(run) {
+    const names = [];
+    let generic;
+    const add = (name) => {
+        if (GENERIC.has(name))
+            generic ??= name;
+        else if (!names.some((known) => known.toLowerCase() === name.toLowerCase()))
+            names.push(name);
+    };
+    const addSimilar = (family) => {
+        const word = wordFamily(family);
+        if (word)
+            for (const name of SIMILAR[word])
+                add(name);
+    };
+    const measured = (wordFamily(run.declaredFamily) ?? run.declaredFamily).toLowerCase() === run.family.toLowerCase();
+    if (!measured)
+        addSimilar(run.family);
+    add(run.declaredFamily);
+    addSimilar(run.declaredFamily);
+    if (measured)
+        addSimilar(run.family);
+    return [...names, generic ?? roleGeneric(run.role)];
+}
+const fonts = new Map();
+/**
+ * The `CanvasRenderingContext2D.font` for `run`, in a context whose unit is
+ * one point: the run's size in points, its weight and slant, then the chain.
+ */
+export function canvasFont(run) {
+    const key = `${run.italic}\0${run.bold}\0${run.size}\0${run.role}\0${run.declaredFamily}\0${run.family}`;
+    let font = fonts.get(key);
+    if (font === undefined) {
+        const chain = fontChain(run)
+            .map((name) => (GENERIC.has(name) ? name : `"${name.replaceAll('"', '')}"`))
+            .join(', ');
+        font = `${run.italic ? 'italic ' : ''}${run.bold ? 'bold ' : ''}${run.size}px ${chain}`;
+        fonts.set(key, font);
+    }
+    return font;
+}
+// Canvas rounds font box extents to pixels; retain sub-point precision
+// when raised text sits near a line-grid boundary.
+const MEASURE_SIZE = 1000;
+/** Browser-local fonts only: this neither fetches files nor requests Local Font Access. */
+export function canvasMeasure() {
+    if (typeof OffscreenCanvas === 'undefined')
+        return undefined;
+    const ctx = new OffscreenCanvas(1, 1).getContext('2d');
+    if (!ctx)
+        return undefined;
+    Object.assign(ctx, { lang: CANVAS_TEXT_LANGUAGE });
+    const cache = new Map();
+    return (family, declaredFamily, bold, italic, text, kern = false) => {
+        const role = family === 'sans-serif' ? 'sans' : family === 'monospace' ? 'mono' : 'serif';
+        const font = canvasFont({ family, declaredFamily, role, size: MEASURE_SIZE, bold, italic });
+        const key = `${font}\0${kern}\0${text}`;
+        const known = cache.get(key);
+        if (known)
+            return known;
+        ctx.font = font;
+        ctx.fontKerning = kern ? 'normal' : 'none';
+        const m = ctx.measureText(text);
+        const result = { width: m.width / MEASURE_SIZE, ascent: (m.fontBoundingBoxAscent ?? m.actualBoundingBoxAscent) / MEASURE_SIZE, descent: (m.fontBoundingBoxDescent ?? m.actualBoundingBoxDescent) / MEASURE_SIZE };
+        cache.set(key, result);
+        return result;
+    };
+}

package/dist/core/index.d.ts

@@ -0,0 +1,47 @@
+import type { DocumentKind, Endpoint, PreviewDocument, PreviewPage } from './protocol.js';
+export type * from './display.js';
+export type * from './protocol.js';
+export interface SessionOptions {
+    /** Worker script address; defaults to the bundled worker beside this module. */
+    workerUrl?: string | URL;
+    /** `.wasm` address; defaults to the file next to the wasm glue. */
+    wasmUrl?: string | URL;
+    /** An already created worker (a MessagePort works too); `workerUrl` is then ignored. */
+    worker?: Endpoint;
+}
+type Bytes = Uint8Array | ArrayBuffer;
+export type Read = (name: string) => Bytes | null | undefined | Promise<Bytes | null | undefined>;
+export interface OpenOptions {
+    /** Receive provisional pages while the worker builds the remaining display list. */
+    onPage?: (page: PreviewPage) => void;
+    /** File name used in diagnostics. */
+    name?: string;
+    /**
+     * Defaults to `docx` for zip or OLE compound-file bytes (an encrypted DOCX
+     * or a .doc, rejected with their own code) and for a Word file name
+     * (`.docx`, `.docm`, `.dotx`, `.dotm`, `.doc`); `idoc` otherwise.
+     */
+    kind?: DocumentKind;
+    /** Reads a path relative to the source document (images). Throw or return null when absent. */
+    readResource?: Read;
+}
+export declare class PreviewError extends Error {
+    code: string;
+    diagnostics: PreviewDocument['diagnostics'];
+    constructor(error: {
+        code: string;
+        message: string;
+        diagnostics: PreviewDocument['diagnostics'];
+    });
+}
+export interface Session {
+    open(bytes: Bytes, options?: OpenOptions): Promise<PreviewDocument>;
+    /**
+     * Terminates the worker; pending opens reject. A worker that fails on its
+     * own (script not loaded, message not deserialized) rejects pending and later
+     * opens with `worker-unavailable`; create a new session to retry.
+     */
+    dispose(): void;
+}
+export declare function createSession(options?: SessionOptions): Session;
+export type { Measure } from './fonts.js';

package/dist/core/index.js

@@ -0,0 +1,156 @@
+import { decodeCompact } from './wire.js';
+export class PreviewError extends Error {
+    code;
+    diagnostics;
+    constructor(error) {
+        super(error.message);
+        this.name = 'PreviewError';
+        this.code = error.code;
+        this.diagnostics = error.diagnostics;
+    }
+}
+function isZip(bytes) {
+    return bytes[0] === 0x50 && bytes[1] === 0x4b;
+}
+const OLE_MAGIC = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+function isWordFile(bytes, name) {
+    return (isZip(bytes) ||
+        OLE_MAGIC.every((byte, i) => bytes[i] === byte) ||
+        /\.(docx|docm|dotx|dotm|doc)$/i.test(name ?? ''));
+}
+/** A private copy whose buffer can be transferred (a Node Buffer may share its pool). */
+function copyBytes(bytes) {
+    return new Uint8Array(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
+}
+export function createSession(options = {}) {
+    const worker = options.worker ??
+        (options.workerUrl
+            ? new Worker(options.workerUrl, { type: 'module' })
+            : // Literally `new Worker(new URL(...), ...)`: the form bundlers
+                // (Turbopack, webpack, Vite) recognize to bundle the worker with its
+                // imports. Behind `??` they copy the file as a bare asset instead.
+                new Worker(new URL('./worker.js', import.meta.url), { type: 'module' }));
+    const post = (message, transfer = []) => worker.postMessage(message, transfer);
+    const jobs = new Map();
+    let next = 1;
+    let disposed = false;
+    /** Set once the worker fails: every pending and later open rejects with it. */
+    let broken;
+    const answer = async (read, name) => {
+        if (!read)
+            return null;
+        try {
+            const bytes = await read(name);
+            return bytes ? copyBytes(bytes) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    worker.addEventListener('message', async (event) => {
+        const message = event.data;
+        const job = jobs.get(message.id);
+        if (!job)
+            return;
+        if (message.type === 'pageReset') {
+            job.pages = [];
+            job.images = [];
+            job.previewImages = [];
+            job.outlines = [];
+            return;
+        }
+        if (message.type === 'page') {
+            try {
+                job.images.push(...message.images);
+                const partial = decodeCompact(message.json, message.data, message.images);
+                job.previewImages.push(...partial.images);
+                job.outlines.push(...partial.glyphOutlines ?? []);
+                const page = partial.pages[0];
+                job.pages.push(page);
+                job.options.onPage?.({ page, images: job.previewImages, glyphOutlines: job.outlines, pageCount: partial.pageCount });
+            }
+            catch (error) {
+                jobs.delete(message.id);
+                job.reject(new PreviewError({ code: 'internal-error', message: String(error), diagnostics: [] }));
+            }
+            return;
+        }
+        if (message.type === 'needs') {
+            const answers = await Promise.all(message.needs.map(async (need) => ({
+                need,
+                bytes: await answer(job.options.readResource, need.name),
+            })));
+            if (disposed)
+                return;
+            post({ type: 'resources', id: message.id, answers }, answers.flatMap((a) => (a.bytes ? [a.bytes.buffer] : [])));
+            return;
+        }
+        jobs.delete(message.id);
+        if (message.type === 'opened') {
+            try {
+                const doc = decodeCompact(message.json, message.data, job.options.onPage ? job.images : message.images);
+                if (job.options.onPage) {
+                    if (job.pages.length !== doc.pageCount)
+                        throw new Error('Preview page count mismatch');
+                    doc.pages = job.pages;
+                }
+                job.resolve(doc);
+            }
+            catch (error) {
+                job.reject(new PreviewError({ code: 'internal-error', message: String(error), diagnostics: [] }));
+            }
+        }
+        else
+            job.reject(new PreviewError(message.error));
+    });
+    // A worker script that fails to load or run, or a message that cannot be
+    // deserialized, leaves no reply to wait for: give up on the worker.
+    const fail = (event) => {
+        if (disposed || broken)
+            return;
+        const detail = event.message;
+        broken = new PreviewError({
+            code: 'worker-unavailable',
+            message: `The preview worker failed (${event.type}${detail ? `: ${detail}` : ''})`,
+            diagnostics: [],
+        });
+        worker.terminate?.();
+        for (const job of jobs.values())
+            job.reject(broken);
+        jobs.clear();
+    };
+    worker.addEventListener('error', fail);
+    worker.addEventListener('messageerror', fail);
+    worker.start?.();
+    post({ type: 'init', wasmUrl: options.wasmUrl?.toString() });
+    return {
+        open(input, openOptions = {}) {
+            if (disposed)
+                return Promise.reject(new Error('The preview session is disposed'));
+            if (broken)
+                return Promise.reject(broken);
+            const bytes = copyBytes(input);
+            const id = next++;
+            return new Promise((resolve, reject) => {
+                jobs.set(id, { options: openOptions, resolve, reject, pages: [], images: [], previewImages: [], outlines: [] });
+                post({
+                    type: 'open',
+                    progressive: openOptions.onPage !== undefined,
+                    id,
+                    kind: openOptions.kind ?? (isWordFile(bytes, openOptions.name) ? 'docx' : 'idoc'),
+                    name: openOptions.name ?? 'document.idoc',
+                    bytes,
+                }, [bytes.buffer]);
+            });
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            worker.terminate?.();
+            for (const job of jobs.values())
+                job.reject(new Error('The preview session is disposed'));
+            jobs.clear();
+        },
+    };
+}

package/dist/core/protocol.d.ts

@@ -0,0 +1,137 @@
+import type { DisplayPage, GlyphOutline } from './display.js';
+export type DocumentKind = 'idoc' | 'docx';
+/**
+ * Either end of the channel: a Worker (or a MessagePort) on the session side,
+ * the worker's global scope (or the other port) on the engine side.
+ */
+export interface Endpoint {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    /** On the session side `error` and `messageerror` make the session unusable (`worker-unavailable`). */
+    addEventListener(type: 'message' | 'error' | 'messageerror', listener: (event: MessageEvent) => void): void;
+    start?(): void;
+    terminate?(): void;
+}
+/** A core diagnostic (load, layout or host-resource), as the CLI reports it. */
+export interface Diagnostic {
+    severity: 'error' | 'warning' | string;
+    code: string;
+    message: string;
+    file?: string;
+    line?: number;
+    col?: number;
+    path?: string;
+    nodeId?: string;
+    predicted?: boolean;
+    [key: string]: unknown;
+}
+export interface ConversionLoss {
+    code: string;
+    message: string;
+    /** Export losses (`.idoc`) only: whether the loss is approved. Convert losses (DOCX) have none. */
+    approved?: boolean;
+    /** Where in the source the loss is; for DOCX, in the converted source `<stem>.idoc`. */
+    source?: {
+        file?: string;
+        line?: number;
+        col?: number;
+        path?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface PreviewImage {
+    format: 'png' | 'jpeg' | 'svg+xml';
+    bytes: Uint8Array;
+    /**
+     * A placeholder for an image `readResource` could not give or core could
+     * not read; the matching `image-missing` / `image-format` diagnostic is a
+     * warning. Draw a placeholder box rather than `bytes`.
+     */
+    missing?: boolean;
+    /** Draw washed out, as Word's picture watermark: each channel `min(255, 205 + 0.3 × value)`. */
+    washout?: boolean;
+}
+/** A laid-out document: the whole layout converged, every page at once. */
+export interface FontUse {
+    file: string;
+    sha256: string;
+    faceIndex: number;
+    declaredFamily: string;
+    family: string;
+    style: string;
+    bold: boolean;
+    italic: boolean;
+    syntheticSlant: number;
+    substituted: boolean;
+}
+export interface PreviewDocument {
+    fonts?: FontUse[];
+    glyphOutlines?: GlyphOutline[];
+    pageCount: number;
+    pages: DisplayPage[];
+    images: PreviewImage[];
+    /** Load diagnostics, plus warnings about resources the host could not give. */
+    diagnostics: Diagnostic[];
+    layoutDiagnostics: Diagnostic[];
+    /** For `.idoc`: what export to DOCX would lose. For DOCX: what DOCX conversion lost. */
+    conversionLosses: ConversionLoss[];
+}
+/** A lookup core made that the host has not answered yet. */
+export type ResourceNeed = {
+    kind: 'asset';
+    name: string;
+};
+export type ToWorker = {
+    type: 'init';
+    wasmUrl?: string;
+} | {
+    type: 'open';
+    id: number;
+    kind: DocumentKind;
+    name: string;
+    bytes: Uint8Array;
+    progressive?: boolean;
+}
+/** Answers to a `needs` message; `bytes: null` means the host has none. */
+ | {
+    type: 'resources';
+    id: number;
+    answers: {
+        need: ResourceNeed;
+        bytes: Uint8Array | null;
+    }[];
+};
+export interface PreviewPage {
+    page: DisplayPage;
+    images: PreviewImage[];
+    glyphOutlines: GlyphOutline[];
+    pageCount: number;
+}
+export type FromWorker = {
+    type: 'pageReset';
+    id: number;
+} | {
+    type: 'page';
+    id: number;
+    json: string;
+    data: Uint8Array;
+    images: Uint8Array[];
+} | {
+    type: 'needs';
+    id: number;
+    needs: ResourceNeed[];
+} | {
+    type: 'opened';
+    id: number;
+    json: string;
+    images: Uint8Array[];
+    data: Uint8Array;
+} | {
+    type: 'failed';
+    id: number;
+    error: {
+        code: string;
+        message: string;
+        diagnostics: Diagnostic[];
+    };
+};

package/dist/core/protocol.js

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

package/dist/core/wire.d.ts

@@ -0,0 +1,14 @@
+import type { Glyph, GlyphShape, LineGlyph } from './display.js';
+import type { PreviewDocument } from './protocol.js';
+interface Packed {
+    f64: Float64Array;
+    u32: Uint32Array;
+    count: number;
+    texts: string[];
+    shapes: GlyphShape[][];
+}
+export declare function packedGlyphs(glyphs: readonly Glyph[]): Packed | undefined;
+export declare function glyphX(glyphs: readonly LineGlyph[], index: number): number;
+export declare function glyphOffset(glyphs: readonly LineGlyph[], index: number): number;
+export declare function decodeCompact(json: string, data: Uint8Array, images: Uint8Array[]): PreviewDocument;
+export {};

package/dist/core/wire.js

@@ -0,0 +1,100 @@
+const glyphRecords = new WeakMap();
+const lineRecords = new WeakMap();
+export function packedGlyphs(glyphs) {
+    return glyphRecords.get(glyphs);
+}
+export function glyphX(glyphs, index) {
+    const packed = lineRecords.get(glyphs);
+    return packed ? packed.f64[index * 2] : glyphs[index].x;
+}
+export function glyphOffset(glyphs, index) {
+    const packed = lineRecords.get(glyphs);
+    return packed ? packed.u32[index * 4 + 2] : glyphs[index].offset;
+}
+function lazyArray(count, read) {
+    const target = new Array(count);
+    const indexOf = (key) => typeof key === 'string' && /^(0|[1-9]\d*)$/.test(key) ? Number(key) : -1;
+    return new Proxy(target, {
+        get(target, key, receiver) {
+            const index = indexOf(key);
+            return index >= 0 && index < count ? read(index) : Reflect.get(target, key, receiver);
+        },
+        has(target, key) {
+            const index = indexOf(key);
+            return index >= 0 && index < count || Reflect.has(target, key);
+        },
+        ownKeys() { return [...Array.from({ length: count }, (_, i) => String(i)), 'length']; },
+        getOwnPropertyDescriptor(target, key) {
+            const index = indexOf(key);
+            return index >= 0 && index < count
+                ? { value: read(index), writable: false, enumerable: true, configurable: true }
+                : Reflect.getOwnPropertyDescriptor(target, key);
+        },
+        set() { throw new TypeError('Compact preview glyph arrays are read-only'); },
+        deleteProperty() { throw new TypeError('Compact preview glyph arrays are read-only'); },
+        defineProperty() { throw new TypeError('Compact preview glyph arrays are read-only'); },
+    });
+}
+function range(value, kind, data) {
+    if (typeof value !== 'object' || value === null || !('offset' in value) || !('count' in value) || !('kind' in value)
+        || value.kind !== kind || typeof value.offset !== 'number' || typeof value.count !== 'number'
+        || !Number.isSafeInteger(value.offset) || !Number.isSafeInteger(value.count)
+        || value.offset < 0 || value.count < 0 || value.offset % 8 !== 0
+        || value.offset + value.count * (kind === 'glyph' ? 32 : 16) > data.byteLength) {
+        throw new Error('Invalid compact glyph range');
+    }
+    return { offset: value.offset, count: value.count, kind };
+}
+export function decodeCompact(json, data, images) {
+    const parsed = JSON.parse(json);
+    if (parsed.wireVersion !== 1 || !Array.isArray(parsed.texts) || !parsed.texts.every(text => typeof text === 'string')
+        || !Array.isArray(parsed.shapes) || parsed.images.length !== images.length || data.byteOffset % 8 !== 0
+        || new Uint8Array(new Uint32Array([1]).buffer)[0] !== 1)
+        throw new Error('Invalid compact preview');
+    const { texts, shapes, wireVersion: _, ...document } = parsed;
+    function records(value, kind) {
+        const { offset, count } = range(value, kind, data);
+        const bytes = count * (kind === 'glyph' ? 32 : 16);
+        const packed = {
+            f64: new Float64Array(data.buffer, data.byteOffset + offset, bytes / 8),
+            u32: new Uint32Array(data.buffer, data.byteOffset + offset, bytes / 4), count, texts, shapes,
+        };
+        if (kind === 'glyph')
+            for (let i = 0; i < count; i++) {
+                if (packed.u32[i * 8 + 5] >= texts.length || packed.u32[i * 8 + 6] > 7 || (packed.u32[i * 8 + 6] & 6) === 6 || packed.u32[i * 8 + 7] > shapes.length)
+                    throw new Error('Invalid compact glyph reference');
+            }
+        return packed;
+    }
+    function visitItems(items) {
+        for (const item of items) {
+            if (item.kind === 'glyphs') {
+                const p = records(item.glyphs, 'glyph');
+                const glyphs = lazyArray(p.count, i => {
+                    const flags = p.u32[i * 8 + 6];
+                    const shape = p.u32[i * 8 + 7];
+                    return {
+                        x: p.f64[i * 4], width: p.f64[i * 4 + 1], offset: p.u32[i * 8 + 4], text: texts[p.u32[i * 8 + 5]],
+                        shapes: shape === 0 ? [] : shapes[shape - 1],
+                        ...(flags & 1 ? { unmeasured: true } : {}),
+                        ...(flags & 2 ? { generated: 'automatic' } : flags & 4 ? { generated: 'manual' } : {}),
+                    };
+                });
+                glyphRecords.set(glyphs, p);
+                item.glyphs = glyphs;
+            }
+            else if (item.kind === 'clip' || item.kind === 'turn' || item.kind === 'transform')
+                visitItems(item.items);
+        }
+    }
+    for (const page of document.pages) {
+        visitItems(page.items);
+        for (const line of page.lines) {
+            const p = records(line.glyphs, 'line');
+            const glyphs = lazyArray(p.count, i => ({ x: p.f64[i * 2], offset: p.u32[i * 4 + 2] }));
+            lineRecords.set(glyphs, p);
+            line.glyphs = glyphs;
+        }
+    }
+    return { ...document, images: parsed.images.map((image, i) => ({ ...image, bytes: images[i] })) };
+}

package/dist/core/worker.d.ts

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

package/dist/core/worker.js

@@ -0,0 +1,5 @@
+// Web Worker entry. The session creates it with `new URL('./worker.ts',
+// import.meta.url)` so the host's bundler emits it; hosts without a bundler
+// pass `workerUrl` to createSession instead.
+import { serve } from './engine.js';
+serve(self);

package/dist/view/find-bar.d.ts

@@ -0,0 +1,26 @@
+import type { Finder } from './find.js';
+import type { PageRect } from './viewport.js';
+export interface FindHost {
+    /** The positioned box the bar floats in, over the top-right of the pages. */
+    frame: HTMLElement;
+    finder: Finder;
+    /** Index of the current page, where a new search starts. */
+    currentPage(): number;
+    /** Scroll so the current match shows. */
+    reveal(bounds: PageRect): void;
+    /** Repaint every overlay that exists (the matches changed). */
+    repaint(): void;
+    /** The find bar closed: select the match (if any) and give the preview the keyboard back. */
+    closed(): void;
+}
+export interface FindBar {
+    readonly isOpen: boolean;
+    /** Show the bar and focus its field; with `query`, search for it. */
+    open(query?: string): void;
+    /** Hide the bar and drop the matches. */
+    close(): void;
+    next(): void;
+    previous(): void;
+    destroy(): void;
+}
+export declare function createFindBar(host: FindHost): FindBar;