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

package/native/core/include/pdfcanvas/text_search.h

@@ -0,0 +1,52 @@
+// The two text-search rules that are not PDFium calls: how a match's context
+// reads, and how a page's matches cross the bridge.
+//
+// PURE — no PDFium, no lock, no document — so both are provable on their own,
+// and both have a TypeScript twin that must agree with them:
+// `src/rasterizer/text-search.ts` (the context rule, used by the web engine
+// and the fake) and `parseTextMatches` in `src/rasterizer/native-bridge.ts`
+// (the reader of the JSON written here).
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "pdfcanvas/types.h"
+
+namespace pdfcanvas {
+
+/// Characters of page text a match carries either side of itself. Mirrors
+/// `CONTEXT_CHARS` in `src/rasterizer/text-search.ts`.
+constexpr int kContextChars = 40;
+
+/// Whether a UTF-16 code unit is whitespace as ECMAScript's `\s` defines it —
+/// the exact set `collapseWhitespace` in `text-search.ts` collapses, so a
+/// context reads the same from every engine.
+bool isJsWhitespace(char16_t unit) noexcept;
+
+/// Runs of whitespace collapsed to one U+0020, both ends trimmed. PDFium's
+/// text page carries `\r\n` at every line break and a "find" list wants one
+/// line per hit.
+std::u16string collapseWhitespace(const std::u16string& text);
+
+/// `TextMatch[]` as ONE JSON string, the shape `parseTextMatches` reads:
+///
+///   [{"page":0,"charIndex":6,"charCount":8,
+///     "rects":[{"x":..,"y":..,"width":..,"height":..}],"context":".."}]
+///
+/// THE OUTPUT IS PURE ASCII: every string character outside printable ASCII —
+/// and `"` and `\` — is written as a `\uXXXX` escape of its UTF-16 unit, which
+/// `JSON.parse` reassembles, surrogate pairs included. That is what lets both
+/// bindings hand it over without a transcoding step: JNI's `NewStringUTF`
+/// takes "modified UTF-8", which is identical to ASCII and to nothing else,
+/// and `+[NSString stringWithUTF8String:]` reads ASCII as itself.
+///
+/// NUMBERS ARE LOCALE-PROOF. `%.17g` round-trips a double exactly, but printf
+/// honours `LC_NUMERIC`, and a host that has called `setlocale` for a
+/// comma-decimal locale would get `72,5` — which is not JSON. The one
+/// separator `%g` can emit is replaced back. A non-finite value (which the
+/// search never produces) is written as 0 rather than as the invalid token
+/// `nan`.
+std::string textMatchesToJson(const std::vector<TextMatch>& matches);
+
+}  // namespace pdfcanvas

package/native/core/include/pdfcanvas/types.h

@@ -67,6 +67,47 @@ struct RasterRequest {
   int pixelHeight() const;
 };
 
+/// A rect in page-local doc space: PDF points, y-down, origin at the DISPLAYED
+/// page's top-left. `DocRect` in `src/types.ts`.
+struct DocRect {
+  double x = 0;
+  double y = 0;
+  double width = 0;
+  double height = 0;
+};
+
+/// One page's search, mirroring `TextSearchRequest` in `src/types.ts`: every
+/// option already resolved by `PdfDocument.searchPage`, so no default here can
+/// drift from the TypeScript one.
+struct TextSearchRequest {
+  int page = 0;
+  /// UTF-16 code units, exactly as JavaScript holds them. Neither binding
+  /// transcodes — JNI's `GetStringChars` and `-[NSString getCharacters:]` both
+  /// hand over UTF-16 — and PDFium's `FPDF_WIDESTRING` is UTF-16LE, so the
+  /// query reaches `FPDFText_FindStart` with no UTF-8 step anywhere that could
+  /// mangle a supplementary character (JNI's "modified UTF-8" would).
+  std::u16string query;
+  bool matchCase = false;
+  bool wholeWord = false;
+  /// The HOST's rotation, exactly as `RasterRequest::rotation`: 0/90/180/270,
+  /// anything else refused. Rects come back in the TURNED page's doc space —
+  /// the space that page's rasters are drawn in.
+  int rotation = 0;
+};
+
+/// One hit, mirroring `TextMatch` in `src/types.ts`.
+struct TextMatch {
+  int page = 0;
+  /// PDFium's character index of the first matched character, and the count.
+  int charIndex = 0;
+  int charCount = 0;
+  /// One per text line the match spans, in the request's doc space.
+  std::vector<DocRect> rects;
+  /// `kContextChars` of page text either side, whitespace collapsed. UTF-16,
+  /// for the same reason the query is.
+  std::u16string context;
+};
+
 /// Where a document's bytes come from. Exactly one of `path` / `bytes` is used;
 /// a non-empty path wins.
 struct Source {

package/native/core/pdfcanvas-core.cmake

@@ -19,4 +19,5 @@ set(PDFCANVAS_CORE_SOURCES
   "${PDFCANVAS_CORE_DIR}/src/pixels.cpp"
   "${PDFCANVAS_CORE_DIR}/src/service.cpp"
   "${PDFCANVAS_CORE_DIR}/src/slots.cpp"
+  "${PDFCANVAS_CORE_DIR}/src/text_search.cpp"
 )

package/native/core/src/document.cpp

@@ -12,9 +12,11 @@
 
 #include "fpdf_formfill.h"
 #include "fpdf_progressive.h"
+#include "fpdf_text.h"
 #include "fpdfview.h"
 #include "pdfcanvas/library.h"
 #include "pdfcanvas/slots.h"
+#include "pdfcanvas/text_search.h"
 
 namespace pdfcanvas {
 
@@ -33,6 +35,19 @@ constexpr FPDF_DWORD kTransparent = 0x00000000u;
 /// PDFium's ints are 32-bit; a request past this cannot be expressed at all.
 constexpr long long kMaxInt32 = (std::numeric_limits<int>::max)();
 
+/// 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 its outputs are `int*`: it ROUNDS TO WHOLE DEVICE UNITS. Handed the page
+/// box in points, a rect would come back quantised to whole points, 4 px off
+/// the glyphs at scale 4. So the box is handed over at this many units per
+/// point and the answer divided back down: 1/1024 pt. The matrix is linear in
+/// the box, so this is exactly the scale-1 mapping with more digits. Mirrors
+/// `SEARCH_UNITS_PER_POINT` in `src/rasterizer/web/engine.ts`.
+constexpr double kSearchUnitsPerPoint = 1024;
+
 /* ------------------------------------------------------------------ *
  * Errors
  * ------------------------------------------------------------------ */
@@ -103,12 +118,16 @@ void preflightPath(const std::string& path) {
   }
 }
 
-void checkCancelled(Cancellation* signal, const char* stage) {
+void checkCancelled(Cancellation* signal, const char* stage, const char* what = "Render") {
   if (signal != nullptr && signal->isCancelled()) {
-    throw PdfError(ErrorCode::Cancelled, std::string("Render cancelled (") + stage + ").");
+    throw PdfError(ErrorCode::Cancelled, std::string(what) + " cancelled (" + stage + ").");
   }
 }
 
+bool isQuarterTurn(int rotation) {
+  return rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270;
+}
+
 /* ------------------------------------------------------------------ *
  * Geometry
  * ------------------------------------------------------------------ */
@@ -192,6 +211,10 @@ struct Document::Impl {
   struct LoadedPage {
     int index = -1;
     FPDF_PAGE page = nullptr;
+    /// The page's TEXT, parsed on its first search and then held for as long
+    /// as the page is: a find box re-searches on every keystroke. Null until
+    /// then — a page that is only ever rendered never pays for it.
+    FPDF_TEXTPAGE text = nullptr;
     uint64_t lastUse = 0;
   };
   std::vector<LoadedPage> cache;
@@ -230,12 +253,40 @@ struct Document::Impl {
       // FORM_OnBeforeClosePage in unloadPage.
       FORM_OnAfterLoadPage(page, form);
     }
-    cache.push_back({index, page, ++useCounter});
+    LoadedPage entry;
+    entry.index = index;
+    entry.page = page;
+    entry.lastUse = ++useCounter;
+    cache.push_back(entry);
     return page;
   }
 
+  /// Requires the library lock. The text page of `index`, loading the page
+  /// (and making it the most recently used) first.
+  FPDF_TEXTPAGE loadTextPage(int index) {
+    loadPage(index);
+    for (auto& entry : cache) {
+      if (entry.index != index) continue;
+      if (entry.text == nullptr) {
+        entry.text = FPDFText_LoadPage(entry.page);
+        if (entry.text == nullptr) {
+          throw PdfError(ErrorCode::Corrupt,
+                         "PDFium could not read the text of page " + std::to_string(index) + ".");
+        }
+      }
+      return entry.text;
+    }
+    // Unreachable: loadPage either put the entry there or threw.
+    throw PdfError(ErrorCode::BackendFailure, "Page " + std::to_string(index) + " left the cache.");
+  }
+
   void unloadPage(LoadedPage& entry) {
     if (entry.page == nullptr) return;
+    // The text page FIRST: PDFium requires it closed before its page.
+    if (entry.text != nullptr) {
+      FPDFText_ClosePage(entry.text);
+      entry.text = nullptr;
+    }
     if (form != nullptr) FORM_OnBeforeClosePage(entry.page, form);
     FPDF_ClosePage(entry.page);
     entry.page = nullptr;
@@ -365,8 +416,7 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
                        " at (" + std::to_string(request.x) + ", " + std::to_string(request.y) + ").");
   }
 
-  if (request.rotation != 0 && request.rotation != 90 && request.rotation != 180 &&
-      request.rotation != 270) {
+  if (!isQuarterTurn(request.rotation)) {
     // Refused rather than folded: `45 / 90` is 0 in integer arithmetic, and a
     // request that asked for a turn must not quietly come back upright.
     throw PdfError(ErrorCode::BackendFailure,
@@ -533,4 +583,137 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
   return out;
 }
 
+/* ------------------------------------------------------------------ *
+ * Text search
+ * ------------------------------------------------------------------ */
+
+namespace {
+
+/// `kContextChars` either side of `[charIndex, charIndex + charCount)`, out of
+/// the text page, collapsed. The window is clamped to the page's text, so a
+/// match near an edge carries less on that side rather than padding. Exactly
+/// `readContext` in `src/rasterizer/web/engine.ts`.
+std::u16string readContext(FPDF_TEXTPAGE text, int totalChars, int charIndex, int charCount) {
+  const int start = (std::max)(0, charIndex - kContextChars);
+  const int end = (std::min)(totalChars, charIndex + charCount + kContextChars);
+  const int count = end - start;
+  if (count <= 0) return {};
+  // `count + 1` units: PDFium writes the terminator, and its return value
+  // counts it.
+  std::vector<unsigned short> buffer(static_cast<size_t>(count) + 1, 0);
+  const int written = FPDFText_GetText(text, start, count, buffer.data());
+  std::u16string raw;
+  for (int i = 0; i + 1 < written; i++) raw += static_cast<char16_t>(buffer[static_cast<size_t>(i)]);
+  return collapseWhitespace(raw);
+}
+
+}  // namespace
+
+std::vector<TextMatch> Document::searchText(const TextSearchRequest& request, Cancellation* signal) {
+  checkCancelled(signal, "before start", "Search");
+  if (impl_->closed) {
+    throw PdfError(ErrorCode::BackendFailure, "Document handle is closed.");
+  }
+  const PageGeometry& geometry = this->geometry(request.page);
+  if (!isQuarterTurn(request.rotation)) {
+    // Refused, as a render refuses it: rects for a turn nobody draws would be
+    // rects in no space at all.
+    throw PdfError(ErrorCode::BackendFailure,
+                   "Rotation must be 0, 90, 180 or 270, got " + std::to_string(request.rotation) + ".");
+  }
+  if (request.query.empty()) return {};
+
+  // THE DISPLAYED PAGE'S BOX, as the renderer hands it to PDFium: the
+  // post-/Rotate extents, swapped for a host quarter turn — then scaled up,
+  // because `FPDF_PageToDevice` rounds to whole units.
+  const bool turned = request.rotation == 90 || request.rotation == 270;
+  const double displayedWidth = turned ? geometry.height : geometry.width;
+  const double displayedHeight = turned ? geometry.width : geometry.height;
+  const long long sizeX = std::llround(displayedWidth * kSearchUnitsPerPoint);
+  const long long sizeY = std::llround(displayedHeight * kSearchUnitsPerPoint);
+  if (sizeX <= 0 || sizeY <= 0 || sizeX > kMaxInt32 || sizeY > kMaxInt32) {
+    throw PdfError(ErrorCode::BackendFailure,
+                   "Page " + std::to_string(request.page) + " is too large to map search rects on.");
+  }
+  // Per axis, from the ROUNDED box, so the division undoes exactly the scale
+  // PDFium applied rather than the one that was asked for.
+  const double pointsPerUnitX = displayedWidth / static_cast<double>(sizeX);
+  const double pointsPerUnitY = displayedHeight / static_cast<double>(sizeY);
+  const int rotate = request.rotation / 90;
+  const unsigned long flags = (request.matchCase ? FPDF_MATCHCASE : 0u) |
+                              (request.wholeWord ? FPDF_MATCHWHOLEWORD : 0u);
+
+  std::lock_guard<std::mutex> lock(Library::mutex());
+  checkCancelled(signal, "after lock", "Search");
+  if (impl_->closed) {
+    throw PdfError(ErrorCode::BackendFailure, "Document handle is closed.");
+  }
+
+  // The text page first: it loads (or re-uses) the page it belongs to, and a
+  // page loaded afterwards could evict it.
+  FPDF_TEXTPAGE text = impl_->loadTextPage(request.page);
+  FPDF_PAGE page = impl_->loadPage(request.page);
+  const int totalChars = FPDFText_CountChars(text);
+
+  // `c_str()` is terminated, which is what an FPDF_WIDESTRING must be.
+  // `char16_t` and `unsigned short` are the same 16 bits on every target.
+  static_assert(sizeof(char16_t) == sizeof(FPDF_WCHAR), "UTF-16 unit size");
+  FPDF_SCHHANDLE find =
+      FPDFText_FindStart(text, reinterpret_cast<FPDF_WIDESTRING>(request.query.c_str()), flags, 0);
+  if (find == nullptr) return {};
+  struct CloseFind {
+    FPDF_SCHHANDLE handle;
+    ~CloseFind() { FPDFText_FindClose(handle); }
+  } closeFind{find};
+
+  const auto toDevice = [&](double pageX, double pageY, int& x, int& y) {
+    if (!FPDF_PageToDevice(page, 0, 0, static_cast<int>(sizeX), static_cast<int>(sizeY), rotate,
+                           pageX, pageY, &x, &y)) {
+      throw PdfError(ErrorCode::BackendFailure,
+                     "PDFium could not map a search rect on page " + std::to_string(request.page) +
+                         " to device space.");
+    }
+  };
+
+  std::vector<TextMatch> matches;
+  while (FPDFText_FindNext(find)) {
+    // Between matches, through `poll()` so the test affordance can land a
+    // cancel INSIDE a search. A superseded "find" on a dense drawing stops
+    // here instead of collecting hundreds of hits nobody will see.
+    if (signal != nullptr && signal->poll()) {
+      throw PdfError(ErrorCode::Cancelled, "Search cancelled (between matches).");
+    }
+    const int charIndex = FPDFText_GetSchResultIndex(find);
+    const int charCount = FPDFText_GetSchCount(find);
+    // Cannot happen for a non-empty query; the guard is against looping
+    // forever if PDFium ever reported one.
+    if (charCount <= 0) break;
+
+    TextMatch match;
+    match.page = request.page;
+    match.charIndex = charIndex;
+    match.charCount = charCount;
+    const int rectCount = FPDFText_CountRects(text, charIndex, charCount);
+    for (int i = 0; i < rectCount; i++) {
+      double left = 0, top = 0, right = 0, bottom = 0;
+      if (!FPDFText_GetRect(text, i, &left, &top, &right, &bottom)) continue;
+      // User space, y up (top > bottom). Both corners through the display
+      // matrix; a quarter turn can swap which one is the top-left, so the
+      // rect is min/max of the two.
+      int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+      toDevice(left, top, x1, y1);
+      toDevice(right, bottom, x2, y2);
+      DocRect rect;
+      rect.x = (std::min)(x1, x2) * pointsPerUnitX;
+      rect.y = (std::min)(y1, y2) * pointsPerUnitY;
+      rect.width = std::abs(x2 - x1) * pointsPerUnitX;
+      rect.height = std::abs(y2 - y1) * pointsPerUnitY;
+      match.rects.push_back(rect);
+    }
+    match.context = readContext(text, totalChars, charIndex, charCount);
+    matches.push_back(std::move(match));
+  }
+  return matches;
+}
+
 }  // namespace pdfcanvas

package/native/core/src/service.cpp

@@ -3,6 +3,7 @@
 #include <string>
 
 #include "pdfcanvas/slots.h"
+#include "pdfcanvas/text_search.h"
 
 namespace pdfcanvas {
 
@@ -46,52 +47,66 @@ void Service::registerCancellation(int handle, int64_t token) {
   signals_[signalKey(handle, token)] = std::make_shared<Cancellation>();
 }
 
-RasterPixels Service::render(int handle, const RasterRequest& request, int64_t token,
-                             bool useSlot) {
-  const int64_t key = signalKey(handle, token);
+/// Looks up (or plants) the job's signal and its document under the service
+/// mutex, and unregisters the signal on EVERY path out, including a throw —
+/// otherwise a superseded epoch, which produces a stream of cancelled jobs,
+/// grows the map for the life of the module.
+struct Service::Lease {
+  Service& service;
+  int64_t key;
   std::shared_ptr<Cancellation> signal;
   std::shared_ptr<Document> document;
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    auto found = signals_.find(key);
-    if (found != signals_.end()) {
+
+  Lease(Service& owner, int handle, int64_t token)
+      : service(owner), key(signalKey(handle, token)) {
+    std::lock_guard<std::mutex> lock(service.mutex_);
+    auto found = service.signals_.find(key);
+    if (found != service.signals_.end()) {
       signal = found->second;
     } else {
       // Not registered ahead of time: a caller that dispatched without the
       // register step. It still gets a signal, so a cancel that arrives while
-      // this render runs is honoured.
+      // this job runs is honoured.
       signal = std::make_shared<Cancellation>();
-      signals_.emplace(key, signal);
+      service.signals_.emplace(key, signal);
     }
-    auto doc = documents_.find(handle);
-    document = doc == documents_.end() ? nullptr : doc->second;
-  }
-
-  // Unregistered on EVERY path out, including a throw — otherwise a superseded
-  // epoch, which produces a stream of cancelled renders, grows the map for the
-  // life of the module.
-  struct Unregister {
-    Service* service;
-    int64_t key;
-    ~Unregister() {
-      std::lock_guard<std::mutex> lock(service->mutex_);
-      service->signals_.erase(key);
+    auto doc = service.documents_.find(handle);
+    document = doc == service.documents_.end() ? nullptr : doc->second;
+    if (document == nullptr) {
+      service.signals_.erase(key);
+      throw PdfError(ErrorCode::BackendFailure,
+                     "No open document for handle " + std::to_string(handle) + ".");
     }
-  } unregister{this, key};
+  }
 
-  if (document == nullptr) {
-    throw PdfError(ErrorCode::BackendFailure,
-                   "No open document for handle " + std::to_string(handle) + ".");
+  ~Lease() {
+    std::lock_guard<std::mutex> lock(service.mutex_);
+    service.signals_.erase(key);
   }
 
+  Lease(const Lease&) = delete;
+  Lease& operator=(const Lease&) = delete;
+};
+
+RasterPixels Service::render(int handle, const RasterRequest& request, int64_t token,
+                             bool useSlot) {
+  Lease lease(*this, handle, token);
+
   // Read ONCE per render: whether to reach for a slot. The sink may still
   // refuse, in which case the raster comes back heap-backed and the caller
   // branches on where the pixels ARE, not on what was asked for.
   if (useSlot) {
     SlotSink sink;
-    return document->render(request, signal.get(), &sink);
+    return lease.document->render(request, lease.signal.get(), &sink);
   }
-  return document->render(request, signal.get(), nullptr);
+  return lease.document->render(request, lease.signal.get(), nullptr);
+}
+
+std::string Service::searchJson(int handle, const TextSearchRequest& request, int64_t token) {
+  Lease lease(*this, handle, token);
+  // Serialised HERE rather than in either binding, so the two cannot
+  // disagree about the wire form and the JSON is proven on a laptop.
+  return textMatchesToJson(lease.document->searchText(request, lease.signal.get()));
 }
 
 void Service::cancel(int handle, int64_t token) {

package/native/core/src/text_search.cpp

@@ -0,0 +1,115 @@
+#include "pdfcanvas/text_search.h"
+
+#include <cmath>
+#include <cstdio>
+#include <string>
+
+namespace pdfcanvas {
+
+namespace {
+
+void appendNumber(std::string& out, double value) {
+  if (!std::isfinite(value)) {
+    out += '0';
+    return;
+  }
+  char buffer[40];
+  const int written = std::snprintf(buffer, sizeof(buffer), "%.17g", value);
+  if (written <= 0) {
+    out += '0';
+    return;
+  }
+  for (int i = 0; i < written && buffer[i] != '\0'; i++) {
+    // `%g` emits digits, a sign, an exponent and ONE locale decimal separator.
+    // Anything that is not one of the first three is that separator.
+    const char c = buffer[i];
+    const bool keep = (c >= '0' && c <= '9') || c == '-' || c == '+' || c == 'e' || c == 'E';
+    out += keep ? c : '.';
+  }
+}
+
+void appendString(std::string& out, const std::u16string& text) {
+  static const char kHex[] = "0123456789abcdef";
+  out += '"';
+  for (const char16_t unit : text) {
+    if (unit >= 0x20 && unit < 0x7F && unit != u'"' && unit != u'\\') {
+      out += static_cast<char>(unit);
+    } else {
+      out += "\\u";
+      out += kHex[(unit >> 12) & 0xF];
+      out += kHex[(unit >> 8) & 0xF];
+      out += kHex[(unit >> 4) & 0xF];
+      out += kHex[unit & 0xF];
+    }
+  }
+  out += '"';
+}
+
+}  // namespace
+
+bool isJsWhitespace(char16_t unit) noexcept {
+  // ECMAScript WhiteSpace + LineTerminator: TAB VT FF SP NBSP ZWNBSP, the
+  // Unicode Space_Separator category, LF CR LS PS.
+  switch (unit) {
+    case 0x0009: case 0x000A: case 0x000B: case 0x000C: case 0x000D:
+    case 0x0020: case 0x00A0: case 0x1680:
+    case 0x2028: case 0x2029: case 0x202F: case 0x205F: case 0x3000:
+    case 0xFEFF:
+      return true;
+    default:
+      return unit >= 0x2000 && unit <= 0x200A;
+  }
+}
+
+std::u16string collapseWhitespace(const std::u16string& text) {
+  std::u16string out;
+  out.reserve(text.size());
+  bool pendingSpace = false;
+  for (const char16_t unit : text) {
+    if (isJsWhitespace(unit)) {
+      pendingSpace = !out.empty();  // leading whitespace is dropped
+      continue;
+    }
+    if (pendingSpace) out += u' ';
+    pendingSpace = false;
+    out += unit;
+  }
+  return out;  // trailing whitespace never emitted its space
+}
+
+std::string textMatchesToJson(const std::vector<TextMatch>& matches) {
+  std::string out;
+  out.reserve(64 + matches.size() * 200);
+  out += '[';
+  for (size_t i = 0; i < matches.size(); i++) {
+    const TextMatch& match = matches[i];
+    if (i > 0) out += ',';
+    out += "{\"page\":";
+    out += std::to_string(match.page);
+    out += ",\"charIndex\":";
+    out += std::to_string(match.charIndex);
+    out += ",\"charCount\":";
+    out += std::to_string(match.charCount);
+    out += ",\"rects\":[";
+    for (size_t j = 0; j < match.rects.size(); j++) {
+      const DocRect& rect = match.rects[j];
+      if (j > 0) out += ',';
+      out += "{\"x\":";
+      appendNumber(out, rect.x);
+      out += ",\"y\":";
+      appendNumber(out, rect.y);
+      out += ",\"width\":";
+      appendNumber(out, rect.width);
+      out += ",\"height\":";
+      appendNumber(out, rect.height);
+      out += '}';
+    }
+    out += "],\"context\":";
+    appendString(out, match.context);
+    out += '}';
+  }
+  out += ']';
+  return out;
+}
+
+}  // namespace pdfcanvas

package/native/tests/fixtures.cpp

@@ -204,6 +204,33 @@ Bytes formFieldPage() {
   return w.finish(catalog);
 }
 
+namespace {
+
+Bytes helveticaPage(const std::string& content, int rotate) {
+  Writer w;
+  const int contents = w.add(streamObject(content + "\n"));
+  // Indirect, as the spec prefers for a font resource; written before the page
+  // so /Resources can name the number it actually got.
+  const int font = w.add("<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");
+  const int pagesNumber = w.count() + 2;
+  std::string dict = "<< /Type /Page /Parent " + std::to_string(pagesNumber) + " 0 R /MediaBox [0 0 " +
+                     std::to_string(kLetterW) + " " + std::to_string(kLetterH) + "]";
+  if (rotate != 0) dict += " /Rotate " + std::to_string(rotate);
+  dict += " /Contents " + std::to_string(contents) + " 0 R /Resources << /Font << /F1 " +
+          std::to_string(font) + " 0 R >> >> >>";
+  const int pageObj = w.add(dict);
+  const int pages = w.add("<< /Type /Pages /Kids [" + std::to_string(pageObj) + " 0 R] /Count 1 >>");
+  const int catalog = w.add("<< /Type /Catalog /Pages " + std::to_string(pages) + " 0 R >>");
+  if (pages != pagesNumber) throw std::logic_error("pages object number drifted");
+  return w.finish(catalog);
+}
+
+}  // namespace
+
+Bytes textPage(int rotate) { return helveticaPage(kTextContent, rotate); }
+
+Bytes twoLineTextPage() { return helveticaPage(kTwoLineTextContent, 0); }
+
 /* ------------------------------------------------------------------ *
  * Multi-page fixtures
  * ------------------------------------------------------------------ */

package/native/tests/fixtures.h

@@ -61,6 +61,21 @@ Bytes annotatedPage();
 /// through the document's AcroForm. Content: white page with a red marker.
 Bytes formFieldPage();
 
+/// ONE LINE OF REAL TEXT: "Hello measured world", 24pt Helvetica, baseline at
+/// user-space (72, 700) on a 612x792 page carrying `/Rotate rotate`. The font is
+/// NOT embedded — Helvetica is one of the standard 14, which PDFium substitutes
+/// from its built-in fonts, so it draws and extracts with no font file. The same
+/// bytes as `textPdf` in `src/__tests__/support/pdfium.ts`, so both engines are
+/// asked the same question.
+constexpr const char* kTextContent = "BT /F1 24 Tf 72 700 Td (Hello measured world) Tj ET";
+Bytes textPage(int rotate = 0);
+/// The same line plus "on a second line" 30pt below it, so PDFium's text page
+/// carries a generated line break a match's context must collapse. The same
+/// bytes as `twoLineTextPdf` in `src/__tests__/support/pdfium.ts`.
+constexpr const char* kTwoLineTextContent =
+    "BT /F1 24 Tf 72 700 Td (Hello measured world) Tj 0 -30 Td (on a second line) Tj ET";
+Bytes twoLineTextPage();
+
 /// A single page with explicit boxes, rotation and content.
 Bytes page(Box mediaBox, const Box* cropBox, int rotate, const std::string& content);