@reekon-tools/react-native-pdf-canvas 0.2.1 → 0.4.0

package/dist/rasterizer/native.js

@@ -22,7 +22,7 @@
  */
 import { createRasterizerOverBridge, encodeBase64 } from './native-bridge.js';
 import { PdfError } from '../types.js';
-export { TRANSPORT_PROBE_BYTES, bytesFromResult, decodeBase64, encodeBase64, lookupTakePixels, negotiateTransport, toPageGeometry, } from './native-bridge.js';
+export { TRANSPORT_PROBE_BYTES, bytesFromResult, decodeBase64, encodeBase64, lookupTakePixels, negotiateTransport, parseTextMatches, toPageGeometry, } from './native-bridge.js';
 /**
  * STRAIGHT (un-premultiplied), and — unlike the two constants this replaces —
  * a measurement of the engine rather than of a platform bitmap type.
@@ -56,14 +56,16 @@ export const NATIVE_CAPABILITIES = Object.freeze({
      */
     interruptibleRender: true,
     /**
-     * FALSE, AND A DECLARATION ABOUT THE PACKAGE, NOT THE ENGINE. PDFium has
-     * text extraction, search and link enumeration, so all three could be true
-     * the day a surface for them exists. It does not — see the non-goals — and a
-     * capability that says "yes" about an API no consumer can reach is worse
-     * than one that says "no".
+     * `search` is TRUE since 0.4.0: `searchText` runs PDFium's text API in the
+     * core (`Document::searchText`) and maps every rect through the display
+     * matrix the rasters use, on both platforms, from one C++ implementation.
+     * `text` and `links` stay FALSE, and that is a declaration about the
+     * PACKAGE, not the engine: PDFium can extract text and enumerate links, but
+     * neither has a surface on the seam, and a capability that says "yes" about
+     * an API no consumer can reach is worse than one that says "no".
      */
     text: false,
-    search: false,
+    search: true,
     links: false,
     /**
      * ONE. PDFium is not thread-safe — not across documents, not across threads

package/dist/rasterizer/text-search.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The two text-search rules every backend shares, so that a match's `context`
+ * reads the same whichever engine produced it.
+ *
+ * Pure, Skia-free and platform-free: the web engine, the native bridge's tests
+ * and the fake all reach it, and nothing here knows which one is calling.
+ */
+/** How much page text a match carries either side of itself, in characters. */
+export declare const CONTEXT_CHARS = 40;
+/**
+ * Whitespace runs collapsed to one space, ends trimmed. PDFium's text page
+ * carries `\r\n` at every line break and a "find" list wants one line per hit;
+ * the native core applies the identical rule in C++ (`collapseWhitespace` in
+ * `native/core/src/text_search.cpp`, which matches ECMAScript's `\s` set).
+ */
+export declare function collapseWhitespace(text: string): string;
+/**
+ * `CONTEXT_CHARS` either side of `[index, index + count)` of `text`, collapsed.
+ * The window is clamped to the text, so a match near an edge carries less on
+ * that side rather than padding.
+ */
+export declare function contextAround(text: string, index: number, count: number): string;

package/dist/rasterizer/text-search.js

@@ -0,0 +1,28 @@
+/**
+ * The two text-search rules every backend shares, so that a match's `context`
+ * reads the same whichever engine produced it.
+ *
+ * Pure, Skia-free and platform-free: the web engine, the native bridge's tests
+ * and the fake all reach it, and nothing here knows which one is calling.
+ */
+/** How much page text a match carries either side of itself, in characters. */
+export const CONTEXT_CHARS = 40;
+/**
+ * Whitespace runs collapsed to one space, ends trimmed. PDFium's text page
+ * carries `\r\n` at every line break and a "find" list wants one line per hit;
+ * the native core applies the identical rule in C++ (`collapseWhitespace` in
+ * `native/core/src/text_search.cpp`, which matches ECMAScript's `\s` set).
+ */
+export function collapseWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+/**
+ * `CONTEXT_CHARS` either side of `[index, index + count)` of `text`, collapsed.
+ * The window is clamped to the text, so a match near an edge carries less on
+ * that side rather than padding.
+ */
+export function contextAround(text, index, count) {
+    const start = Math.max(0, index - CONTEXT_CHARS);
+    const end = Math.min(text.length, index + count + CONTEXT_CHARS);
+    return collapseWhitespace(text.slice(start, end));
+}

package/dist/rasterizer/web/client.js

@@ -63,10 +63,11 @@ import { PdfError } from '../../types.js';
  * from `RasterRequest.annotations` — so unlike Android, which can only ever draw
  * them, this backend genuinely honours both settings.
  *
- * `text` / `search` / `links` are false because none of them is implemented.
- * PDFium can do all three (`FPDFText_*`, `FPDFLink_*`) and the seam has no place
- * to expose them yet; declaring them true would be claiming an API that does not
- * exist.
+ * `search` is true: `searchText` runs PDFium's `FPDFText_Find*` in the worker
+ * and maps every rect through the display matrix the rasters use (see
+ * `search` in `./engine.ts`). `text` and `links` stay false because neither
+ * has a surface on the seam; declaring them would be claiming an API that
+ * does not exist.
  *
  * `interruptibleRender: false`, honestly. `FPDF_RenderPageBitmap` is synchronous
  * and a worker reads one message at a time, so nothing can interrupt a render
@@ -89,7 +90,7 @@ const CAPABILITIES = {
     annotations: true,
     interruptibleRender: false,
     text: false,
-    search: false,
+    search: true,
     links: false,
     maxConcurrentRenders: 1,
 };
@@ -259,6 +260,55 @@ function createHandle(connection, backendId, pageCount, pages) {
         }
         return geometry;
     };
+    /**
+     * One job to the worker, with the caller's abort honoured.
+     *
+     * ABORT DOES TWO THINGS, AND ONLY THE FIRST IS GUARANTEED.
+     *
+     * It frees the CALLER immediately — the promise rejects `cancelled` and the
+     * controller stops waiting on a tile it no longer wants. And it posts a
+     * `cancel`, which the worker honours if the job has not started yet (see the
+     * yield in `./session.ts`) and cannot honour if it has. The id is abandoned
+     * either way, so a result that does arrive is dropped rather than resolving
+     * a promise nobody holds.
+     *
+     * This is `interruptibleRender: false` stated as behaviour: cancellation
+     * happens between requests. Renders and searches share it, because the
+     * worker queues them together and a search is as synchronous as a render.
+     */
+    const exchange = async (what, page, message, signal) => {
+        if (closed) {
+            throw new PdfError('backend-failure', `${backendId} handle is closed.`);
+        }
+        requirePage(page);
+        if (signal?.aborted === true) {
+            throw new PdfError('cancelled', `${what === 'render' ? 'Render' : 'Search'} was aborted before it started.`);
+        }
+        const id = connection.nextId();
+        let abort;
+        const cancelled = new Promise((_, reject) => {
+            abort = () => {
+                connection.abandon(id);
+                connection.post({ kind: 'cancel', id });
+                reject(new PdfError('cancelled', `${what === 'render' ? 'Render' : 'Search'} was aborted.`));
+            };
+            signal?.addEventListener('abort', abort, { once: true });
+        });
+        // Nothing awaits this branch when the job wins, and an unhandled
+        // rejection on a promise that lost a race is noise in every console.
+        cancelled.catch(() => { });
+        try {
+            const response = await Promise.race([
+                connection.request(id, message(id)),
+                cancelled,
+            ]);
+            return { id, response };
+        }
+        finally {
+            if (abort !== undefined)
+                signal?.removeEventListener('abort', abort);
+        }
+    };
     return {
         pageCount,
         /**
@@ -268,51 +318,8 @@ function createHandle(connection, backendId, pageCount, pages) {
          */
         pageGeometry: requirePage,
         async render(request, signal) {
-            if (closed) {
-                throw new PdfError('backend-failure', `${backendId} handle is closed.`);
-            }
-            requirePage(request.page);
-            if (signal?.aborted === true) {
-                throw new PdfError('cancelled', 'Render was aborted before it started.');
-            }
-            const id = connection.nextId();
             const startedAt = monotonicNow();
-            /**
-             * ABORT DOES TWO THINGS, AND ONLY THE FIRST IS GUARANTEED.
-             *
-             * It frees the CALLER immediately — the promise rejects `cancelled` and
-             * the controller stops waiting on a tile it no longer wants. And it posts
-             * a `cancel`, which the worker honours if the render has not started yet
-             * (see the yield in `./session.ts`) and cannot honour if it has. The id is
-             * abandoned either way, so a raster that does arrive is dropped rather
-             * than resolving a promise nobody holds.
-             *
-             * This is `interruptibleRender: false` stated as behaviour: cancellation
-             * happens between requests.
-             */
-            let abort;
-            const cancelled = new Promise((_, reject) => {
-                abort = () => {
-                    connection.abandon(id);
-                    connection.post({ kind: 'cancel', id });
-                    reject(new PdfError('cancelled', 'Render was aborted.'));
-                };
-                signal?.addEventListener('abort', abort, { once: true });
-            });
-            // Nothing awaits this branch when the render wins, and an unhandled
-            // rejection on a promise that lost a race is noise in every console.
-            cancelled.catch(() => { });
-            let response;
-            try {
-                response = await Promise.race([
-                    connection.request(id, { kind: 'render', id, request }),
-                    cancelled,
-                ]);
-            }
-            finally {
-                if (abort !== undefined)
-                    signal?.removeEventListener('abort', abort);
-            }
+            const { response } = await exchange('render', request.page, id => ({ kind: 'render', id, request }), signal);
             if (response.kind !== 'rendered') {
                 throw new PdfError('backend-failure', `The worker answered a render with a ${response.kind} message.`);
             }
@@ -345,6 +352,19 @@ function createHandle(connection, backendId, pageCount, pages) {
                 },
             };
         },
+        /**
+         * The request crosses the channel WHOLE — structured-cloned, never
+         * rebuilt field by field — so the flags and the rotation the caller set
+         * are the ones the engine searches with. Asserted in
+         * `__tests__/text-search.test.ts`.
+         */
+        async searchText(request, signal) {
+            const { response } = await exchange('search', request.page, id => ({ kind: 'search', id, request }), signal);
+            if (response.kind !== 'searched') {
+                throw new PdfError('backend-failure', `The worker answered a search with a ${response.kind} message.`);
+            }
+            return response.matches;
+        },
         close() {
             if (closed)
                 return;

package/dist/rasterizer/web/engine.d.ts

@@ -40,7 +40,7 @@
  * likely to be real.
  */
 import type { PdfiumBinding } from './pdfium.js';
-import type { AlphaEncoding, PageGeometry, PixelFormat, RasterRequest } from '../../types.js';
+import type { AlphaEncoding, PageGeometry, PixelFormat, RasterRequest, TextMatch, TextSearchRequest } from '../../types.js';
 export interface PdfiumRasterBytes {
     /** Tight: its own exactly-sized ArrayBuffer, ready to transfer. */
     bytes: Uint8Array;
@@ -55,6 +55,8 @@ export interface PdfiumDocument {
     /** Every page, measured once at open. */
     readonly pages: readonly PageGeometry[];
     render(request: RasterRequest): PdfiumRasterBytes;
+    /** Every match on one page, rects in the displayed page's doc space. */
+    search(request: TextSearchRequest): TextMatch[];
     close(): void;
 }
 /**

package/dist/rasterizer/web/engine.js

@@ -39,7 +39,9 @@
  * exactly where a misregistration would be least likely to be noticed and most
  * likely to be real.
  */
-import { FPDF_ANNOT, FPDF_BITMAP_BGRA, FPDF_REVERSE_BYTE_ORDER, loadError, } from './pdfium.js';
+import { FPDF_ANNOT, FPDF_BITMAP_BGRA, FPDF_MATCHCASE, FPDF_MATCHWHOLEWORD, FPDF_REVERSE_BYTE_ORDER, loadError, } from './pdfium.js';
+import { isPageRotation, ROTATIONS, swapsExtents } from '../../rotation.js';
+import { CONTEXT_CHARS, collapseWhitespace } from '../text-search.js';
 import { PdfError } from '../../types.js';
 /**
  * MEASURED, not inherited from the other backends. An antialiased opaque-white
@@ -64,7 +66,22 @@ const OPAQUE_WHITE = 0xffffffff;
 const TRANSPARENT = 0x00000000;
 /** PDFium's ints are 32-bit; a request past this cannot be expressed at all. */
 const MAX_INT32 = 0x7fffffff;
-const ROTATIONS = [0, 90, 180, 270];
+/**
+ * The device box a search rect is mapped through, in units per PDF point.
+ *
+ * `FPDF_PageToDevice` is the display matrix the rasters use — `/Rotate`, the
+ * CropBox origin and the host's `rotate` all folded in by PDFium itself, which
+ * is the whole reason to go through it rather than restate the arithmetic —
+ * but it ROUNDS ITS OUTPUT TO WHOLE DEVICE UNITS (`FXSYS_roundf`, both axes).
+ * Handed the page box in points, a rect would come back quantised to whole
+ * points: 4 px at scale 4, visibly off the glyphs. So the box is handed over
+ * at this many units per point and the answer divided back down, which gives
+ * 1/1024 pt. The matrix is linear in the box, so this is exactly the scale-1
+ * mapping with more digits; float32 inside PDFium keeps ~0.06 units at the
+ * largest box a 14400 pt page can produce, which is still below 1/10000 pt.
+ * Mirrors `kSearchUnitsPerPoint` in `native/core/src/document.cpp`.
+ */
+const SEARCH_UNITS_PER_POINT = 1024;
 /* ------------------------------------------------------------------ *
  * Open
  * ------------------------------------------------------------------ */
@@ -147,6 +164,40 @@ export function openPdfiumDocument(api, bytes, password) {
     }
     return createDocument(api, document, dataPointer, pages);
 }
+/* ------------------------------------------------------------------ *
+ * Text
+ * ------------------------------------------------------------------ */
+/**
+ * `CONTEXT_CHARS` either side of a match, out of the text page as UTF-16.
+ *
+ * `FPDFText_GetText` wants a buffer of `count + 1` code units and writes the
+ * terminator; what it returns counts the terminator too, so the string is one
+ * unit shorter than the return. Read through a fresh `heapU8()` — the
+ * allocation may have grown the heap.
+ */
+function readContext(api, textPage, totalChars, charIndex, charCount) {
+    const start = Math.max(0, charIndex - CONTEXT_CHARS);
+    const end = Math.min(totalChars, charIndex + charCount + CONTEXT_CHARS);
+    const count = end - start;
+    if (count <= 0)
+        return '';
+    const buffer = api.malloc((count + 1) * 2);
+    if (buffer === 0)
+        return '';
+    try {
+        const written = api.FPDFText_GetText(textPage, start, count, buffer);
+        const heap = api.heapU8();
+        let text = '';
+        for (let i = 0; i < written - 1; i++) {
+            const at = buffer + 2 * i;
+            text += String.fromCharCode((heap[at] ?? 0) | ((heap[at + 1] ?? 0) << 8));
+        }
+        return collapseWhitespace(text);
+    }
+    finally {
+        api.free(buffer);
+    }
+}
 /* ------------------------------------------------------------------ *
  * Render
  * ------------------------------------------------------------------ */
@@ -165,7 +216,19 @@ function createDocument(api, document, dataPointer, pages) {
      */
     let loadedIndex = -1;
     let loadedPage = 0;
+    /**
+     * The loaded page's TEXT page, parsed on the first search of it and held for
+     * as long as the page is. A "find" box re-searches on every keystroke, and
+     * `FPDFText_LoadPage` is the call that walks the content stream for glyphs,
+     * so the cache is what keeps typing cheap. It lives and dies with the page
+     * above it: PDFium requires the text page to be closed before its page.
+     */
+    let loadedTextPage = 0;
     const releasePage = () => {
+        if (loadedTextPage !== 0) {
+            api.FPDFText_ClosePage(loadedTextPage);
+            loadedTextPage = 0;
+        }
         if (loadedPage !== 0) {
             api.FPDF_ClosePage(loadedPage);
             loadedPage = 0;
@@ -195,9 +258,144 @@ function createDocument(api, document, dataPointer, pages) {
         loadedPage = page;
         return page;
     };
+    const loadTextPage = (index) => {
+        const page = loadPage(index);
+        if (loadedTextPage === 0) {
+            const textPage = api.FPDFText_LoadPage(page);
+            if (textPage === 0) {
+                throw new PdfError('corrupt', `PDFium could not read the text of page ${index}.`);
+            }
+            loadedTextPage = textPage;
+        }
+        return { page, textPage: loadedTextPage };
+    };
     return {
         pageCount: pages.length,
         pages,
+        /**
+         * THE RECT MAPPING IS PDFIUM'S OWN DISPLAY MATRIX. `FPDFText_GetRect`
+         * answers in the page's USER space — y up, CropBox origin wherever the
+         * file put it, `/Rotate` not applied — and every raster this engine
+         * produces is drawn through `CPDF_Page::GetDisplayMatrix` for the
+         * displayed box and the host's `rotate`. Mapping each corner through
+         * `FPDF_PageToDevice` with THAT box and THAT rotate is what makes a hit
+         * drawn at the returned rect land on the glyphs in the raster, whatever
+         * the file's `/Rotate` and whatever the host has turned the page by. The
+         * two corners can swap under a turn, so the rect is min/max of both.
+         * Measured against the raster in `__tests__/text-search.test.ts`.
+         */
+        search(request) {
+            if (closed) {
+                throw new PdfError('backend-failure', 'The document is closed.');
+            }
+            const geometry = requirePage(request.page);
+            const rotation = request.rotation ?? 0;
+            if (!isPageRotation(rotation)) {
+                throw new PdfError('backend-failure', `Rotation must be 0, 90, 180 or 270, got ${String(rotation)}.`);
+            }
+            const query = request.query;
+            if (query.length === 0)
+                return [];
+            const { page, textPage } = loadTextPage(request.page);
+            const total = api.FPDFText_CountChars(textPage);
+            // The DISPLAYED page's box, as the renderers hand it to PDFium: the
+            // intrinsic post-`/Rotate` extents, swapped for a quarter turn — and
+            // then scaled up, because `FPDF_PageToDevice` rounds to whole units.
+            const turned = swapsExtents(rotation);
+            const displayedWidth = turned ? geometry.height : geometry.width;
+            const displayedHeight = turned ? geometry.width : geometry.height;
+            const sizeX = Math.round(displayedWidth * SEARCH_UNITS_PER_POINT);
+            const sizeY = Math.round(displayedHeight * SEARCH_UNITS_PER_POINT);
+            // Per axis, from the rounded box itself, so the division undoes exactly
+            // the scale PDFium applied rather than the one that was asked for.
+            const pointsPerUnitX = displayedWidth / sizeX;
+            const pointsPerUnitY = displayedHeight / sizeY;
+            const rotate = rotation / 90;
+            // One scratch block: four doubles for a rect, two ints for a device
+            // point, then the query as UTF-16LE plus its terminator. THE OUT-PARAMS
+            // GO FIRST, AND THAT ORDER IS LOAD-BEARING: Emscripten's `getValue` reads
+            // a double as `HEAPF64[ptr >> 3]` and an int as `HEAP32[ptr >> 2]`, so an
+            // unaligned pointer is silently rounded DOWN and the read returns
+            // neighbouring bytes. PDFium's own stores are unaligned-safe, so nothing
+            // fails — the rects just come back as garbage. (Measured: with the query
+            // first, "measured" put the doubles at +18 and every rect was nonsense.)
+            // `malloc` is 8-aligned, and 32 + 8 keeps the query 2-aligned after it.
+            // Allocated AFTER the page loads and written through a fresh `heapU8()`
+            // — the heap can grow under either.
+            const rectOut = 0;
+            const deviceOut = 4 * 8;
+            const queryAt = deviceOut + 2 * 4;
+            const queryBytes = (query.length + 1) * 2;
+            const scratch = api.malloc(queryAt + queryBytes);
+            if (scratch === 0) {
+                throw new PdfError('out-of-memory', `Could not allocate ${queryBytes} bytes for the search query.`);
+            }
+            let find = 0;
+            try {
+                const heap = api.heapU8();
+                const queryPointer = scratch + queryAt;
+                for (let i = 0; i < query.length; i++) {
+                    const unit = query.charCodeAt(i);
+                    heap[queryPointer + 2 * i] = unit & 0xff;
+                    heap[queryPointer + 2 * i + 1] = unit >> 8;
+                }
+                heap[queryPointer + 2 * query.length] = 0;
+                heap[queryPointer + 2 * query.length + 1] = 0;
+                const flags = (request.matchCase ? FPDF_MATCHCASE : 0) |
+                    (request.wholeWord ? FPDF_MATCHWHOLEWORD : 0);
+                find = api.FPDFText_FindStart(textPage, queryPointer, flags, 0);
+                if (find === 0)
+                    return [];
+                const toDevice = (pageX, pageY) => {
+                    if (!api.FPDF_PageToDevice(page, 0, 0, sizeX, sizeY, rotate, pageX, pageY, scratch + deviceOut, scratch + deviceOut + 4)) {
+                        throw new PdfError('backend-failure', `PDFium could not map (${pageX}, ${pageY}) on page ` +
+                            `${request.page} to device space.`);
+                    }
+                    return [
+                        api.getInt32(scratch + deviceOut),
+                        api.getInt32(scratch + deviceOut + 4),
+                    ];
+                };
+                const matches = [];
+                while (api.FPDFText_FindNext(find)) {
+                    const charIndex = api.FPDFText_GetSchResultIndex(find);
+                    const charCount = api.FPDFText_GetSchCount(find);
+                    // A zero-length result cannot happen for a non-empty query; the
+                    // guard is against looping forever if PDFium ever reported one.
+                    if (charCount <= 0)
+                        break;
+                    const rects = [];
+                    const rectCount = api.FPDFText_CountRects(textPage, charIndex, charCount);
+                    for (let i = 0; i < rectCount; i++) {
+                        if (!api.FPDFText_GetRect(textPage, i, scratch + rectOut, scratch + rectOut + 8, scratch + rectOut + 16, scratch + rectOut + 24)) {
+                            continue;
+                        }
+                        // left, top, right, bottom — user space, so top > bottom.
+                        const [x1, y1] = toDevice(api.getDouble(scratch + rectOut), api.getDouble(scratch + rectOut + 8));
+                        const [x2, y2] = toDevice(api.getDouble(scratch + rectOut + 16), api.getDouble(scratch + rectOut + 24));
+                        rects.push({
+                            x: Math.min(x1, x2) * pointsPerUnitX,
+                            y: Math.min(y1, y2) * pointsPerUnitY,
+                            width: Math.abs(x2 - x1) * pointsPerUnitX,
+                            height: Math.abs(y2 - y1) * pointsPerUnitY,
+                        });
+                    }
+                    matches.push({
+                        page: request.page,
+                        charIndex,
+                        charCount,
+                        rects,
+                        context: readContext(api, textPage, total, charIndex, charCount),
+                    });
+                }
+                return matches;
+            }
+            finally {
+                if (find !== 0)
+                    api.FPDFText_FindClose(find);
+                api.free(scratch);
+            }
+        },
         render(request) {
             if (closed) {
                 throw new PdfError('backend-failure', 'The document is closed.');
@@ -215,6 +413,13 @@ function createDocument(api, document, dataPointer, pages) {
                     `${docRect.width}x${docRect.height} at ` +
                     `(${docRect.x}, ${docRect.y}).`);
             }
+            // Read as `?? 0`, so a request built before the field existed renders
+            // as it always did; validated, because from here on it is arithmetic
+            // and `45 / 90` would silently be "upright".
+            const rotation = request.rotation ?? 0;
+            if (!isPageRotation(rotation)) {
+                throw new PdfError('backend-failure', `Rotation must be 0, 90, 180 or 270, got ${String(rotation)}.`);
+            }
             // At least one pixel: a sub-pixel rect is a legitimate ask at low zoom,
             // and a zero-sized bitmap is not a thing PDFium (or Skia) accepts.
             const width = Math.max(1, Math.round(docRect.width * scale));
@@ -223,8 +428,18 @@ function createDocument(api, document, dataPointer, pages) {
             // the negated one.
             const startX = -Math.round(docRect.x * scale);
             const startY = -Math.round(docRect.y * scale);
-            const pageWidth = Math.round(geometry.width * scale);
-            const pageHeight = Math.round(geometry.height * scale);
+            // THE PAGE BOX PDFIUM IS HANDED IS THE DISPLAYED ONE. `size_x` / `size_y`
+            // describe the box the page is drawn INTO after `rotate` is applied —
+            // `CPDF_Page::GetDisplayMatrix` maps the page's HEIGHT onto `size_x` for
+            // rotate 1 and 3 — so a quarter turn swaps the intrinsic extents here.
+            // Without the swap the turned page is squashed into the upright box and
+            // every pixel is stretched; with it, `docRect` (already in the turned
+            // page's space, see `RasterRequest.rotation`) needs nothing: the start
+            // offsets slide the whole turned page exactly as they slide an upright
+            // one.
+            const turned = swapsExtents(rotation);
+            const pageWidth = Math.round((turned ? geometry.height : geometry.width) * scale);
+            const pageHeight = Math.round((turned ? geometry.width : geometry.height) * scale);
             if (width * height > MAX_INT32 / 4 ||
                 pageWidth > MAX_INT32 ||
                 pageHeight > MAX_INT32) {
@@ -255,10 +470,12 @@ function createDocument(api, document, dataPointer, pages) {
                 }
                 const page = loadPage(request.page);
                 api.FPDF_RenderPageBitmap(bitmap, page, startX, startY, pageWidth, pageHeight, 
-                // Device rotation, NOT the page's `/Rotate`. PDFium applies the
-                // page's own rotation itself, and `geometry` is already post-rotation
-                // — passing anything but 0 here would rotate a second time.
-                0, FPDF_REVERSE_BYTE_ORDER | (request.annotations ? FPDF_ANNOT : 0));
+                // The HOST's rotation, in quarter turns clockwise — and never the
+                // page's own `/Rotate`. PDFium has already folded that into
+                // `geometry` and into the render, so passing it here would turn the
+                // page twice; `rotation` is layered on top of it, which is exactly
+                // what this argument exists for.
+                rotation / 90, FPDF_REVERSE_BYTE_ORDER | (request.annotations ? FPDF_ANNOT : 0));
                 // READ, NEVER ASSUMED. Measured tight (`width * 4`) at 1, 3, 7, 13, 1023
                 // and 1025 px — but "tight today" is not "tight always", and a wrong
                 // stride shears the image instead of failing.

package/dist/rasterizer/web/pdfium.d.ts

@@ -46,6 +46,9 @@ import type { PdfErrorCode } from '../../types.js';
 export declare const FPDF_BITMAP_BGRA = 4;
 /** Draw PDF-embedded annotations. Answers `RasterRequest.annotations`. */
 export declare const FPDF_ANNOT = 1;
+/** `FPDFText_FindStart` flags. Answer `TextSearchRequest.matchCase` / `.wholeWord`. */
+export declare const FPDF_MATCHCASE = 1;
+export declare const FPDF_MATCHWHOLEWORD = 2;
 /**
  * Write RGBA instead of BGRA.
  *
@@ -95,11 +98,18 @@ export interface PdfiumHeap {
     free(pointer: number): void;
     /** Reads an `FS_SIZEF` component — PDFium's float32. */
     getFloat(pointer: number): number;
+    /** Reads a `double*` out-parameter — `FPDFText_GetRect`'s four edges. */
+    getDouble(pointer: number): number;
+    /** Reads an `int*` out-parameter — `FPDF_PageToDevice`'s two coordinates. */
+    getInt32(pointer: number): number;
 }
 /**
  * Exactly the PDFium entry points this backend calls. Nothing speculative:
- * text, search, links and form filling are all absent because none of them is
- * implemented, and `RasterizerCapabilities` says so.
+ * links and form filling are absent because neither is implemented, and
+ * `RasterizerCapabilities` says so. The `FPDFText_*` group is the text search
+ * surface (`RasterizerHandle.searchText`), and `FPDF_PageToDevice` is how its
+ * rects are mapped into the displayed page's doc space — see `search` in
+ * `./engine.ts`.
  */
 export interface PdfiumBinding extends PdfiumHeap {
     /**
@@ -149,6 +159,40 @@ export interface PdfiumBinding extends PdfiumHeap {
     FPDFBitmap_GetBuffer(bitmap: number): number;
     FPDFBitmap_GetStride(bitmap: number): number;
     FPDF_RenderPageBitmap(bitmap: number, page: number, startX: number, startY: number, sizeX: number, sizeY: number, rotate: number, flags: number): void;
+    /**
+     * Maps a point in the page's USER space onto a device box. `sizeX`/`sizeY`
+     * are the box the page is displayed INTO after `rotate` — the same box the
+     * render call takes, extents swapped for a quarter turn — and the output is
+     * ROUNDED TO WHOLE DEVICE UNITS by PDFium (`FXSYS_roundf` on both), which is
+     * why `search` scales the box up before calling it.
+     */
+    FPDF_PageToDevice(page: number, startX: number, startY: number, sizeX: number, sizeY: number, rotate: number, pageX: number, pageY: number, deviceXOut: number, deviceYOut: number): boolean;
+    /** Parses the page's text. Balanced by `FPDFText_ClosePage`. */
+    FPDFText_LoadPage(page: number): number;
+    FPDFText_ClosePage(textPage: number): void;
+    FPDFText_CountChars(textPage: number): number;
+    /**
+     * Writes `count` UTF-16 code units plus a terminating 0 to `buffer` (which
+     * must hold `count + 1` units) and returns how many units it wrote, the
+     * terminator included.
+     */
+    FPDFText_GetText(textPage: number, startIndex: number, count: number, buffer: number): number;
+    /**
+     * `findWhat` is an `FPDF_WIDESTRING`: UTF-16LE code units in the heap with a
+     * terminating 0. Returns a search handle, or 0 for an empty query.
+     */
+    FPDFText_FindStart(textPage: number, findWhat: number, flags: number, startIndex: number): number;
+    FPDFText_FindNext(handle: number): boolean;
+    FPDFText_FindClose(handle: number): void;
+    FPDFText_GetSchResultIndex(handle: number): number;
+    FPDFText_GetSchCount(handle: number): number;
+    /** Counts the rects a char range occupies and caches them for `GetRect`. */
+    FPDFText_CountRects(textPage: number, startIndex: number, count: number): number;
+    /**
+     * One cached rect, as four `double*` out-parameters in the page's USER space
+     * (y up, so `top > bottom`).
+     */
+    FPDFText_GetRect(textPage: number, rectIndex: number, leftOut: number, topOut: number, rightOut: number, bottomOut: number): boolean;
 }
 /**
  * The shape of `@embedpdf/pdfium`'s `WrappedPdfiumModule`, restated as the
@@ -189,6 +233,24 @@ export interface PdfiumWasmModule {
     FPDFBitmap_GetBuffer(bitmap: number): number;
     FPDFBitmap_GetStride(bitmap: number): number;
     FPDF_RenderPageBitmap(bitmap: number, page: number, startX: number, startY: number, sizeX: number, sizeY: number, rotate: number, flags: number): null;
+    FPDF_PageToDevice(page: number, startX: number, startY: number, sizeX: number, sizeY: number, rotate: number, pageX: number, pageY: number, deviceXOut: number, deviceYOut: number): boolean;
+    FPDFText_LoadPage(page: number): number;
+    FPDFText_ClosePage(textPage: number): null;
+    FPDFText_CountChars(textPage: number): number;
+    FPDFText_GetText(textPage: number, startIndex: number, count: number, buffer: number): number;
+    /**
+     * `findWhat` is a POINTER (`number`), not a JS string: the real module's
+     * signature is `["number", "number", "number", "number"]`, so the UTF-16LE
+     * query is written into the heap by the caller. A `"string"` here would
+     * have `tsc` accept a call the wasm would read as a garbage pointer.
+     */
+    FPDFText_FindStart(textPage: number, findWhat: number, flags: number, startIndex: number): number;
+    FPDFText_FindNext(handle: number): boolean;
+    FPDFText_FindClose(handle: number): null;
+    FPDFText_GetSchResultIndex(handle: number): number;
+    FPDFText_GetSchCount(handle: number): number;
+    FPDFText_CountRects(textPage: number, startIndex: number, count: number): number;
+    FPDFText_GetRect(textPage: number, rectIndex: number, leftOut: number, topOut: number, rightOut: number, bottomOut: number): boolean;
 }
 /**
  * Turn an initialised `@embedpdf/pdfium` module into a `PdfiumBinding`.