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

package/dist/rasterizer/native-bridge.js

@@ -227,6 +227,63 @@ export function negotiateTransport(native, lookup = lookupTakePixels) {
         return BASE64_TRANSPORT;
     }
 }
+/* ------------------------------------------------------------------ *
+ * Text matches
+ * ------------------------------------------------------------------ */
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+function toDocRect(value, where) {
+    const rect = value;
+    if (rect === null ||
+        typeof rect !== 'object' ||
+        !isFiniteNumber(rect.x) ||
+        !isFiniteNumber(rect.y) ||
+        !isFiniteNumber(rect.width) ||
+        !isFiniteNumber(rect.height)) {
+        throw new PdfError('backend-failure', `The native module's search result has a malformed rect at ${where}.`);
+    }
+    return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+}
+/**
+ * The core's JSON, checked field by field into `TextMatch[]`.
+ *
+ * Checked rather than cast because the string was built by hand in C++
+ * (`native/core/src/text_search.cpp`) with no JSON library on either side of
+ * it, and a host drawing hits from a `rects` entry that is `undefined` would
+ * fail inside its own draw code with no mention of this package. Every
+ * failure here is `backend-failure` naming what was wrong.
+ */
+export function parseTextMatches(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (error) {
+        throw new PdfError('backend-failure', `The native module's search result is not JSON: ` +
+            `${error?.message ?? String(error)}`, { cause: error });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new PdfError('backend-failure', "The native module's search result is not an array.");
+    }
+    return parsed.map((entry, i) => {
+        const match = entry;
+        if (match === null ||
+            typeof match !== 'object' ||
+            !isFiniteNumber(match.page) ||
+            !isFiniteNumber(match.charIndex) ||
+            !isFiniteNumber(match.charCount) ||
+            !Array.isArray(match.rects) ||
+            typeof match.context !== 'string') {
+            throw new PdfError('backend-failure', `The native module's search result has a malformed match at [${i}].`);
+        }
+        return {
+            page: match.page,
+            charIndex: match.charIndex,
+            charCount: match.charCount,
+            rects: match.rects.map((rect, j) => toDocRect(rect, `[${i}].rects[${j}]`)),
+            context: match.context,
+        };
+    });
+}
 /* ------------------------------------------------------------------ *
  * Geometry
  * ------------------------------------------------------------------ */
@@ -387,6 +444,44 @@ export function createNativeHandle(native, opened, transport, alpha, label) {
                 },
             };
         },
+        async searchText(request, signal) {
+            if (closed) {
+                throw new PdfError('backend-failure', `${label} rasterizer handle is closed.`);
+            }
+            requirePage(request.page);
+            if (signal?.aborted) {
+                throw new PdfError('cancelled', 'Search was aborted before it started.');
+            }
+            // The capability says true for this binary's JS, but an OTA bundle can
+            // be newer than the binary under it, and `NativeModules.PdfCanvas` only
+            // has the methods that binary exports. Named here rather than left as
+            // "native.search is not a function" from inside the bridge.
+            if (typeof native.search !== 'function') {
+                throw new PdfError('unsupported', 'This app binary predates text search in the PdfCanvas native ' +
+                    'module (0.4.0). A native rebuild is needed; an OTA update ' +
+                    'cannot add it.');
+            }
+            const token = nextToken++;
+            const onAbort = () => native.cancel(opened.handle, token);
+            signal?.addEventListener('abort', onAbort, { once: true });
+            let json;
+            try {
+                json = await native.search(opened.handle, {
+                    page: request.page,
+                    query: request.query,
+                    matchCase: request.matchCase,
+                    wholeWord: request.wholeWord,
+                    rotation: request.rotation,
+                }, token);
+            }
+            catch (error) {
+                throw toPdfError(error, `Could not search page ${request.page}`);
+            }
+            finally {
+                signal?.removeEventListener('abort', onAbort);
+            }
+            return parseTextMatches(json);
+        },
         close() {
             if (closed)
                 return;

package/dist/rasterizer/native.d.ts

@@ -22,8 +22,8 @@
  */
 import type { TakePixels } from './native-bridge.js';
 import type { PageRasterizer, RasterizerCapabilities } from '../types.js';
-export { TRANSPORT_PROBE_BYTES, bytesFromResult, decodeBase64, encodeBase64, lookupTakePixels, negotiateTransport, toPageGeometry, } from './native-bridge.js';
-export type { NativeOpenResult, NativePdfPage, NativeRenderRequest, NativeRenderResult, NativeSource, NativeTransport, PdfCanvasNativeModule, TakePixels, } from './native-bridge.js';
+export { TRANSPORT_PROBE_BYTES, bytesFromResult, decodeBase64, encodeBase64, lookupTakePixels, negotiateTransport, parseTextMatches, toPageGeometry, } from './native-bridge.js';
+export type { NativeOpenResult, NativePdfPage, NativeRenderRequest, NativeRenderResult, NativeSearchRequest, NativeSource, NativeTransport, PdfCanvasNativeModule, TakePixels, } from './native-bridge.js';
 export type NativePlatform = 'ios' | 'android';
 export declare const NATIVE_CAPABILITIES: RasterizerCapabilities;
 export interface NativeRasterizerOptions {

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,8 +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
@@ -65,6 +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;
+/**
+ * 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.');