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

package/native/tests/test_document.cpp

@@ -5,6 +5,9 @@
 // stride shear, a y-flip, a page ignored, an annotation drawn when it was not
 // asked for, a transparent page composited as black.
 
+#include <algorithm>
+#include <chrono>
+#include <cmath>
 #include <string>
 #include <thread>
 
@@ -661,3 +664,308 @@ TEST(closeWhileRenderingIsSafe) {
   CHECK(!failure);
   CHECK(document->isClosed());
 }
+
+/* ------------------------------------------------------------------ *
+ * Text search
+ * ------------------------------------------------------------------ */
+
+namespace {
+
+TextSearchRequest searchFor(const std::u16string& query, int rotation = 0, bool matchCase = false,
+                            bool wholeWord = false) {
+  TextSearchRequest request;
+  request.page = 0;
+  request.query = query;
+  request.rotation = rotation;
+  request.matchCase = matchCase;
+  request.wholeWord = wholeWord;
+  return request;
+}
+
+std::string showRect(const DocRect& r) {
+  return "{" + std::to_string(r.x) + ", " + std::to_string(r.y) + ", " + std::to_string(r.width) + " x " +
+         std::to_string(r.height) + "}";
+}
+
+/// THE GEOMETRY PROOF. Renders the doc-space neighbourhood of `rect` at scale
+/// 2 through the real engine, with the SAME host rotation the search used, and
+/// asks the pixels whether the rect is on the glyphs:
+///
+///  - a meaningful share of the pixels inside it are ink (measured 32% for
+///    "measured" at 24pt: text is mostly counter and gap even in a tight box);
+///  - the ink found within 3pt of it has its edges within 0.75pt of the
+///    rect's. MEASURED worst edge: 0.357pt here, 0.525pt on the web engine —
+///    pixel-centre sampling (±0.25pt at scale 2) plus up to a pixel of
+///    antialiased fringe a rotated glyph throws past its unhinted box.
+///    Sub-point precision is pinned by the metrics test, not here; this is the
+///    contract check — the rect is on the glyphs of the raster it is drawn over;
+///  - a probe 2pt outside the middle of each edge is paper. Along the line the
+///    probes fall in the inter-word spaces (6.7pt at 24pt), across it on bare
+///    page.
+///
+/// A rect left in PDF user space (y up), mapped without the host's turn, or
+/// quantised to whole points fails at least one of these by a wide margin.
+void checkRectIsOnInk(Document& document, const DocRect& rect, int rotation, const std::string& label) {
+  const double scale = 2;
+  const double pad = 12;
+  RasterRequest request = px::request(0, rect.x - pad, rect.y - pad, rect.width + 2 * pad, rect.height + 2 * pad, scale);
+  request.rotation = rotation;
+  auto raster = document.render(request, nullptr, nullptr);
+
+  const auto inked = [&](int x, int y) { return px::at(raster, x, y).r < 128; };
+  const auto paper = [&](double docX, double docY) {
+    const int x = static_cast<int>((docX - request.x) * scale);
+    const int y = static_cast<int>((docY - request.y) * scale);
+    return px::at(raster, x, y).near(kWhite, 6);
+  };
+
+  int inside = 0;
+  int ink = 0;
+  double minX = 1e9, minY = 1e9, maxX = -1e9, maxY = -1e9;
+  for (int y = 0; y < raster.height; y++) {
+    for (int x = 0; x < raster.width; x++) {
+      const double docX = request.x + (x + 0.5) / scale;
+      const double docY = request.y + (y + 0.5) / scale;
+      const bool inRect = docX >= rect.x && docX <= rect.x + rect.width && docY >= rect.y &&
+                          docY <= rect.y + rect.height;
+      const bool nearRect = docX >= rect.x - 3 && docX <= rect.x + rect.width + 3 && docY >= rect.y - 3 &&
+                            docY <= rect.y + rect.height + 3;
+      if (inRect) {
+        inside++;
+        if (inked(x, y)) ink++;
+      }
+      if (nearRect && px::at(raster, x, y).r < 250) {
+        minX = (std::min)(minX, docX);
+        maxX = (std::max)(maxX, docX);
+        minY = (std::min)(minY, docY);
+        maxY = (std::max)(maxY, docY);
+      }
+    }
+  }
+  const std::string where = label + " rect " + showRect(rect) + "\n" + px::map(raster, 32, 12);
+  REQUIRE(inside > 0);
+  CHECK_MSG(ink * 100 > inside * 15, where + " only " + std::to_string(ink) + "/" + std::to_string(inside) + " inked");
+  CHECK_MSG(std::fabs(minX - rect.x) < 0.75, where + " ink left " + std::to_string(minX));
+  CHECK_MSG(std::fabs(minY - rect.y) < 0.75, where + " ink top " + std::to_string(minY));
+  CHECK_MSG(std::fabs(maxX - (rect.x + rect.width)) < 0.75, where + " ink right " + std::to_string(maxX));
+  CHECK_MSG(std::fabs(maxY - (rect.y + rect.height)) < 0.75, where + " ink bottom " + std::to_string(maxY));
+  const double midX = rect.x + rect.width / 2;
+  const double midY = rect.y + rect.height / 2;
+  CHECK_MSG(paper(rect.x - 2, midY), where + " not paper left of the rect");
+  CHECK_MSG(paper(rect.x + rect.width + 2, midY), where + " not paper right of the rect");
+  CHECK_MSG(paper(midX, rect.y - 2), where + " not paper above the rect");
+  CHECK_MSG(paper(midX, rect.y + rect.height + 2), where + " not paper below the rect");
+}
+
+/// `rect` on a W x H page, turned a quarter clockwise `quarters` times: the
+/// doc-space turn every raster of a rotated page is drawn in.
+DocRect turnRect(DocRect rect, double width, double height, int quarters) {
+  for (int i = 0; i < quarters; i++) {
+    rect = DocRect{height - (rect.y + rect.height), rect.x, rect.height, rect.width};
+    std::swap(width, height);
+  }
+  return rect;
+}
+
+void checkSameRect(const DocRect& actual, const DocRect& expected, const std::string& label) {
+  // 1/1024 pt is the mapping's resolution; two of them is the round-trip.
+  const double tolerance = 2.0 / 1024;
+  CHECK_MSG(std::fabs(actual.x - expected.x) <= tolerance && std::fabs(actual.y - expected.y) <= tolerance &&
+                std::fabs(actual.width - expected.width) <= tolerance &&
+                std::fabs(actual.height - expected.height) <= tolerance,
+            label + ": " + showRect(actual) + " vs " + showRect(expected));
+}
+
+}  // namespace
+
+/// CATCHES: a char index counted in bytes or from 1, a count that includes the
+/// terminator, a context that is not the page's own text.
+TEST(searchFindsAWordWithItsCharIndexAndContext) {
+  auto document = openFixture(fixtures::textPage(), "search-basic.pdf");
+  auto matches = document->searchText(searchFor(u"measured"), nullptr);
+  REQUIRE(matches.size() == 1);
+  CHECK_EQ(matches[0].page, 0);
+  CHECK_EQ(matches[0].charIndex, 6);
+  CHECK_EQ(matches[0].charCount, 8);
+  CHECK(!matches[0].rects.empty());
+  CHECK(matches[0].context == u"Hello measured world");
+}
+
+/// CATCHES: the two flags swapped or dropped on the way to FPDFText_FindStart.
+TEST(searchHonoursMatchCaseAndWholeWord) {
+  auto document = openFixture(fixtures::textPage(), "search-flags.pdf");
+  CHECK_EQ(document->searchText(searchFor(u"MEASURED"), nullptr).size(), size_t{1});
+  CHECK_EQ(document->searchText(searchFor(u"MEASURED", 0, true), nullptr).size(), size_t{0});
+  CHECK_EQ(document->searchText(searchFor(u"measured", 0, true), nullptr).size(), size_t{1});
+  CHECK_EQ(document->searchText(searchFor(u"meas"), nullptr).size(), size_t{1});
+  CHECK_EQ(document->searchText(searchFor(u"meas", 0, false, true), nullptr).size(), size_t{0});
+  CHECK_EQ(document->searchText(searchFor(u"measured", 0, false, true), nullptr).size(), size_t{1});
+  // Every occurrence, in reading order: "Hell[o] measured w[o]rld".
+  auto os = document->searchText(searchFor(u"o"), nullptr);
+  REQUIRE(os.size() == 2);
+  CHECK_EQ(os[0].charIndex, 4);
+  CHECK_EQ(os[1].charIndex, 16);
+  CHECK(document->searchText(searchFor(u"absent"), nullptr).empty());
+}
+
+/// CATCHES: the context read raw. PDFium's text page carries a generated line
+/// break between the two lines; a "find" list wants one line per hit.
+TEST(aContextCollapsesTheLineBreak) {
+  auto document = openFixture(fixtures::twoLineTextPage(), "search-two-lines.pdf");
+  auto matches = document->searchText(searchFor(u"second"), nullptr);
+  REQUIRE(matches.size() == 1);
+  CHECK(matches[0].context == u"Hello measured world on a second line");
+  const DocRect first = document->searchText(searchFor(u"measured"), nullptr).at(0).rects.at(0);
+  CHECK(matches[0].rects.at(0).y > first.y + first.height);
+}
+
+TEST(anEmptyQueryFindsNothing) {
+  auto document = openFixture(fixtures::textPage(), "search-empty.pdf");
+  CHECK(document->searchText(searchFor(u""), nullptr).empty());
+}
+
+/// THE CONTRACT: a rect is where the glyphs are in the page's doc space — the
+/// space its rasters use — proven two independent ways.
+///
+/// ABSOLUTE PLACEMENT from the font's own metrics, to a tenth of a point.
+/// Helvetica's AFM: "Hello " advances H 722 + e 556 + l 222 + l 222 + o 556 +
+/// space 278 = 2556 units, `m`'s left bearing is 65, "measured" advances 4446
+/// with `d` ending its box at 499 of 556, `d` rises to 718 and the round
+/// letters dip to -15. At 24pt from (72, 700), y-down on a 792pt page:
+/// left 134.904, right 238.680, top 74.768, bottom 92.360. The tolerance is
+/// 0.5pt because THE TWO ENGINES' FONTS DIFFER, measured: each PDFium build
+/// substitutes its own built-in face for an unembedded Helvetica. This build
+/// is 0.024 / 0.048 / 0.36 / 0.096pt off (left / top / right / bottom — its
+/// `d` ends 15 font units earlier); the web engine's is within 0.001pt on
+/// three edges. Each engine's rects match ITS OWN raster, which is the
+/// contract. Catches user space left unflipped and a CropBox origin not
+/// subtracted.
+///
+/// THE RESOLUTION, font-independent: every edge is an exact multiple of
+/// 1/1024pt (`kSearchUnitsPerPoint`) and, for a word at an arbitrary
+/// position, not a whole point — which catches the page box handed to
+/// `FPDF_PageToDevice` in points, a quantisation the scale-2 pixel proof is
+/// too coarse to see.
+///
+/// And against the RASTER — see `checkRectIsOnInk`.
+TEST(searchRectsLandOnTheGlyphs) {
+  auto document = openFixture(fixtures::textPage(), "search-geometry.pdf");
+  auto matches = document->searchText(searchFor(u"measured"), nullptr);
+  REQUIRE(matches.size() == 1);
+  REQUIRE(matches[0].rects.size() == 1);
+  const DocRect rect = matches[0].rects[0];
+  CHECK_MSG(std::fabs(rect.x - 134.904) < 0.5, showRect(rect));
+  CHECK_MSG(std::fabs(rect.x + rect.width - 238.68) < 0.5, showRect(rect));
+  CHECK_MSG(std::fabs(rect.y - 74.768) < 0.5, showRect(rect));
+  CHECK_MSG(std::fabs(rect.y + rect.height - 92.36) < 0.5, showRect(rect));
+
+  bool allWhole = true;
+  for (const double value : {rect.x, rect.y, rect.width, rect.height}) {
+    CHECK_MSG(std::fabs(value * 1024 - std::round(value * 1024)) < 1e-6, showRect(rect));
+    allWhole = allWhole && value == std::round(value);
+  }
+  CHECK_MSG(!allWhole, "quantised to whole points: " + showRect(rect));
+
+  checkRectIsOnInk(*document, rect, 0, "upright");
+}
+
+/// A phrase spanning a space is ONE rect on its one line: the union of its
+/// glyphs' boxes, starting at its first glyph rather than at the line.
+TEST(aPhraseAcrossAWordBoundaryIsTheUnionOfItsGlyphs) {
+  auto document = openFixture(fixtures::textPage(), "search-phrase.pdf");
+  const DocRect phrase = document->searchText(searchFor(u"lo me"), nullptr).at(0).rects.at(0);
+  const DocRect lo = document->searchText(searchFor(u"lo"), nullptr).at(0).rects.at(0);
+  const DocRect me = document->searchText(searchFor(u"me"), nullptr).at(0).rects.at(0);
+  const double top = (std::min)(lo.y, me.y);
+  const double bottom = (std::max)(lo.y + lo.height, me.y + me.height);
+  checkSameRect(phrase, DocRect{lo.x, top, me.x + me.width - lo.x, bottom - top}, "\"lo me\"");
+}
+
+/// CATCHES: the host's rotation ignored by the mapping (rects stay upright
+/// while the raster turns), applied anticlockwise, or applied without the
+/// swapped box. Every quarter is also the upright rect turned in doc space.
+TEST(searchRectsTurnWithTheHostRotation) {
+  auto document = openFixture(fixtures::textPage(), "search-host-rotate.pdf");
+  const DocRect upright = document->searchText(searchFor(u"measured"), nullptr).at(0).rects.at(0);
+  for (int rotation : {90, 180, 270}) {
+    auto matches = document->searchText(searchFor(u"measured", rotation), nullptr);
+    REQUIRE(matches.size() == 1);
+    REQUIRE(matches[0].rects.size() == 1);
+    const DocRect rect = matches[0].rects[0];
+    checkSameRect(rect, turnRect(upright, fixtures::kLetterW, fixtures::kLetterH, rotation / 90),
+                  "turned " + std::to_string(rotation));
+    checkRectIsOnInk(*document, rect, rotation, "host " + std::to_string(rotation));
+  }
+}
+
+/// CATCHES: the file's own /Rotate left out of the mapping — the display
+/// matrix is what folds it in, which is why the core goes through
+/// FPDF_PageToDevice rather than restating the arithmetic. A page saved at
+/// /Rotate 90 reads exactly like an upright page turned 90 by the host, and
+/// turning it a further 270 unwinds it to the upright page's rects.
+TEST(searchRectsFollowTheDocumentsRotate) {
+  auto saved = openFixture(fixtures::textPage(90), "search-saved-rotate.pdf");
+  auto plain = openFixture(fixtures::textPage(), "search-plain.pdf");
+  CHECK_NEAR(saved->geometry(0).width, 792, 0.01);
+  const DocRect rect = saved->searchText(searchFor(u"measured"), nullptr).at(0).rects.at(0);
+  checkRectIsOnInk(*saved, rect, 0, "/Rotate 90");
+  checkSameRect(rect, plain->searchText(searchFor(u"measured", 90), nullptr).at(0).rects.at(0),
+                "/Rotate 90 vs host 90");
+  const DocRect unwound = saved->searchText(searchFor(u"measured", 270), nullptr).at(0).rects.at(0);
+  checkSameRect(unwound, plain->searchText(searchFor(u"measured"), nullptr).at(0).rects.at(0),
+                "/Rotate 90 + host 270 vs upright");
+  checkRectIsOnInk(*saved, unwound, 270, "/Rotate 90 + host 270");
+}
+
+/// Refused, as a render refuses it — and the document stays usable.
+TEST(searchRefusesWhatARenderRefuses) {
+  auto document = openFixture(fixtures::textPage(), "search-refuse.pdf");
+  for (int bad : {45, -90, 360}) {
+    EXPECT_ERROR(document->searchText(searchFor(u"measured", bad), nullptr), ErrorCode::BackendFailure);
+  }
+  TextSearchRequest missing = searchFor(u"measured");
+  missing.page = 3;
+  EXPECT_ERROR(document->searchText(missing, nullptr), ErrorCode::NotFound);
+  CHECK_EQ(document->searchText(searchFor(u"measured"), nullptr).size(), size_t{1});
+  document->close();
+  EXPECT_ERROR(document->searchText(searchFor(u"measured"), nullptr), ErrorCode::BackendFailure);
+}
+
+/// A cancel before the lock, and one that lands BETWEEN matches — the
+/// affordance flips the flag on the second poll, which happens after the
+/// first "o" was collected and before the second is. Either way the search
+/// throws `cancelled` and the page is searchable afterwards.
+TEST(aCancelStopsASearchBetweenMatches) {
+  auto document = openFixture(fixtures::textPage(), "search-cancel.pdf");
+  Cancellation before;
+  before.cancel();
+  EXPECT_ERROR(document->searchText(searchFor(u"o"), &before), ErrorCode::Cancelled);
+
+  Cancellation between;
+  between.cancelAfterPolls(2);
+  EXPECT_ERROR(document->searchText(searchFor(u"o"), &between), ErrorCode::Cancelled);
+  CHECK(between.isCancelled());
+
+  Cancellation live;
+  CHECK_EQ(document->searchText(searchFor(u"o"), &live).size(), size_t{2});
+  CHECK(!live.isCancelled());
+}
+
+/// The text page lives and dies with its cached page: searching more pages
+/// than the cache holds evicts pages that CARRY a text page, and PDFium
+/// requires the text page closed before its page. Then render and search the
+/// survivors again — a wrong unload order is a use-after-free here.
+TEST(searchedPagesAreEvictedCleanly) {
+  auto document = openFixture(
+      fixtures::coloredPages({{1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {0, 0, 0}, {1, 1, 1}}, 40, 40),
+      "search-evict.pdf");
+  for (int round = 0; round < 2; round++) {
+    for (int page = 0; page < 5; page++) {
+      TextSearchRequest request = searchFor(u"x");
+      request.page = page;
+      CHECK(document->searchText(request, nullptr).empty());
+      CHECK_EQ(document->render(px::request(page, 0, 0, 40, 40, 1), nullptr, nullptr).width, 40);
+    }
+  }
+  CHECK_PIXEL(document->render(px::request(0, 0, 0, 40, 40, 1), nullptr, nullptr), 20, 20, kRed);
+}

package/native/tests/test_service.cpp

@@ -1,11 +1,16 @@
 // The facade both bindings marshal to.
 
+#include <clocale>
+#include <cmath>
+#include <limits>
+#include <string>
 #include <thread>
 
 #include "fixtures.h"
 #include "harness.h"
 #include "pdfcanvas/service.h"
 #include "pdfcanvas/slots.h"
+#include "pdfcanvas/text_search.h"
 #include "pixels_util.h"
 
 using namespace pdfcanvas;
@@ -128,3 +133,108 @@ TEST(openErrorsCarryTheirCodeThroughTheService) {
   EXPECT_ERROR(service.open(locked), ErrorCode::PasswordRequired);
   CHECK_EQ(service.openCount(), size_t{0});
 }
+
+/* ------------------------------------------------------------------ *
+ * Text search: the wire form
+ * ------------------------------------------------------------------ */
+
+namespace {
+
+TextSearchRequest measured(int page = 0) {
+  TextSearchRequest request;
+  request.page = page;
+  request.query = u"measured";
+  return request;
+}
+
+}  // namespace
+
+/// The JSON both bindings hand to JS, end to end through the service. The
+/// exact prefix pins the key names and order `parseTextMatches` reads; the
+/// context pins that the string crossed as itself.
+TEST(serviceSearchReturnsTheWireJson) {
+  Service service;
+  const auto opened = service.open(fileSource(fixtures::textPage(), "svc-search.pdf"));
+  const std::string json = service.searchJson(opened.handle, measured(), 1);
+  CHECK_MSG(json.rfind("[{\"page\":0,\"charIndex\":6,\"charCount\":8,\"rects\":[{\"x\":", 0) == 0, json);
+  CHECK_MSG(json.find(",\"context\":\"Hello measured world\"}]") != std::string::npos, json);
+  for (const char c : json) CHECK_MSG(static_cast<unsigned char>(c) < 0x80, json);
+
+  TextSearchRequest none = measured();
+  none.query = u"absent";
+  CHECK_EQ(service.searchJson(opened.handle, none, 2), std::string("[]"));
+  EXPECT_ERROR(service.searchJson(999, measured(), 3), ErrorCode::BackendFailure);
+}
+
+/// The same (handle, token) registry as a render: a registered, cancelled
+/// token stops the search, and the signal is consumed so the token is reusable.
+TEST(aRegisteredCancellationStopsASearch) {
+  Service service;
+  const auto opened = service.open(fileSource(fixtures::textPage(), "svc-search-cancel.pdf"));
+  service.registerCancellation(opened.handle, 4);
+  service.cancel(opened.handle, 4);
+  EXPECT_ERROR(service.searchJson(opened.handle, measured(), 4), ErrorCode::Cancelled);
+  CHECK(service.searchJson(opened.handle, measured(), 4) != "[]");
+  // Invalidation closes the document under a search as under a render.
+  service.invalidate();
+  EXPECT_ERROR(service.searchJson(opened.handle, measured(), 5), ErrorCode::BackendFailure);
+}
+
+/// CATCHES: a raw non-ASCII byte in the output (JNI's NewStringUTF reads
+/// "modified UTF-8", which only agrees with UTF-8 on ASCII), an unescaped
+/// quote or backslash, a control character, a surrogate pair split wrongly.
+TEST(theWireJsonIsPureAsciiAndEscapesEverythingElse) {
+  TextMatch match;
+  match.page = 2;
+  match.charIndex = 10;
+  match.charCount = 3;
+  match.rects.push_back(DocRect{72.5, 0.1, 100, 17.568359375});
+  match.context = u"a\"b\\c\n\u00e9\U0001F600";
+  const std::string json = textMatchesToJson({match});
+  CHECK_EQ(json, std::string("[{\"page\":2,\"charIndex\":10,\"charCount\":3,\"rects\":[{\"x\":72.5,"
+                             "\"y\":0.10000000000000001,\"width\":100,\"height\":17.568359375}],"
+                             "\"context\":\"a\\u0022b\\u005cc\\u000a\\u00e9\\ud83d\\ude00\"}]"));
+  CHECK_EQ(textMatchesToJson({}), std::string("[]"));
+}
+
+/// CATCHES: `nan` / `inf` written as tokens JSON does not have, and a comma
+/// decimal separator from a host that has called setlocale(LC_NUMERIC, ...).
+TEST(theWireJsonNumbersAreLocaleProofAndFinite) {
+  TextMatch match;
+  match.rects.push_back(DocRect{std::nan(""), std::numeric_limits<double>::infinity(), -1.25, 1e21});
+  CHECK_EQ(textMatchesToJson({match}),
+           std::string("[{\"page\":0,\"charIndex\":0,\"charCount\":0,\"rects\":[{\"x\":0,\"y\":0,"
+                       "\"width\":-1.25,\"height\":1e+21}],\"context\":\"\"}]"));
+
+  const std::string previous = std::setlocale(LC_NUMERIC, nullptr);
+  const char* candidates[] = {"de_DE.UTF-8", "de_DE.utf8", "fr_FR.UTF-8", "fr_FR.utf8", "de_DE"};
+  bool switched = false;
+  for (const char* name : candidates) {
+    if (std::setlocale(LC_NUMERIC, name) != nullptr) {
+      switched = true;
+      break;
+    }
+  }
+  if (switched) {
+    char probe[16];
+    std::snprintf(probe, sizeof(probe), "%.1f", 0.5);
+    TextMatch comma;
+    comma.rects.push_back(DocRect{72.5, 0, 0, 0});
+    const std::string json = textMatchesToJson({comma});
+    std::setlocale(LC_NUMERIC, previous.c_str());
+    // Only meaningful where the locale really does use a comma.
+    if (std::string(probe) == "0,5") CHECK_MSG(json.find("\"x\":72.5,") != std::string::npos, json);
+  }
+}
+
+/// The context rule, pinned to ECMAScript's `\s` — the rule the web engine and
+/// the fake apply through `collapseWhitespace` in `text-search.ts`.
+TEST(collapseWhitespaceMatchesTheJavaScriptRule) {
+  CHECK(collapseWhitespace(u"  Hello\r\n\tmeasured\u00a0\u2003 world \ufeff") == u"Hello measured world");
+  CHECK(collapseWhitespace(u"") == u"");
+  CHECK(collapseWhitespace(u" \r\n ") == u"");
+  // Not whitespace to JavaScript, so not collapsed here either.
+  CHECK(collapseWhitespace(u"a\u200bb\u0085c") == u"a\u200bb\u0085c");
+  CHECK(isJsWhitespace(u'\u3000'));
+  CHECK(!isJsWhitespace(u'x'));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/react-native-pdf-canvas",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "PDF pages as Skia images, drawn at exact doc-space rects inside somebody else's transform. One PDFium engine on iOS, Android and web. Owns no canvas, no gestures, no viewport state.",
   "author": "REEKON Tools",
   "license": "Apache-2.0",