@embedpdf/engines 1.3.1 → 1.3.3

package/dist/{engine-BVe88qdX.js → engine-B2N46cyz.js}

@@ -724,12 +724,14 @@ class PdfiumEngine {
           message: `FPDF_GetPageSizeByIndexF failed`
         });
       }
+      const rotation = this.pdfiumModule.EPDF_GetPageRotationByIndex(docPtr, index);
       const page = {
         index,
         size: {
           width: this.pdfiumModule.pdfium.getValue(sizePtr, "float"),
           height: this.pdfiumModule.pdfium.getValue(sizePtr + 4, "float")
-        }
+        },
+        rotation
       };
       pages.push(page);
     }
@@ -806,12 +808,14 @@ class PdfiumEngine {
           message: `FPDF_GetPageSizeByIndexF failed`
         });
       }
+      const rotation = this.pdfiumModule.EPDF_GetPageRotationByIndex(docPtr, index);
       const page = {
         index,
         size: {
           width: this.pdfiumModule.pdfium.getValue(sizePtr, "float"),
           height: this.pdfiumModule.pdfium.getValue(sizePtr + 4, "float")
-        }
+        },
+        rotation
       };
       pages.push(page);
     }
@@ -1301,7 +1305,7 @@ class PdfiumEngine {
         message: "can not set the name of the annotation"
       });
     }
-    if (!this.setPageAnnoRect(page, pageCtx.pagePtr, annotationPtr, annotation.rect)) {
+    if (!this.setPageAnnoRect(page, annotationPtr, annotation.rect)) {
       this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
       pageCtx.release();
       this.logger.perf(
@@ -1432,7 +1436,7 @@ class PdfiumEngine {
       );
       return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "annotation not found" });
     }
-    if (!this.setPageAnnoRect(page, pageCtx.pagePtr, annotPtr, annotation.rect)) {
+    if (!this.setPageAnnoRect(page, annotPtr, annotation.rect)) {
       this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
       pageCtx.release();
       this.logger.perf(
@@ -2791,6 +2795,23 @@ class PdfiumEngine {
     }
     return true;
   }
+  /** Build page-space image placement matrix from a device-space rect. */
+  imageMatrixFromDeviceRect(page, rect) {
+    const x0 = rect.origin.x;
+    const y0 = rect.origin.y;
+    const x1 = x0 + rect.size.width;
+    const y1 = y0 + rect.size.height;
+    const BL = this.convertDevicePointToPagePoint(page, { x: x0, y: y1 });
+    const BR = this.convertDevicePointToPagePoint(page, { x: x1, y: y1 });
+    const TL = this.convertDevicePointToPagePoint(page, { x: x0, y: y0 });
+    const a = BR.x - BL.x;
+    const b = BR.y - BL.y;
+    const c = TL.x - BL.x;
+    const d = TL.y - BL.y;
+    const e = BL.x;
+    const f = BL.y;
+    return { a, b, c, d, e, f };
+  }
   /**
    * Add image object to annotation
    * @param docPtr - pointer to pdf document object
@@ -2804,76 +2825,63 @@ class PdfiumEngine {
    * @private
    */
   addImageObject(docPtr, page, pagePtr, annotationPtr, rect, imageData) {
-    const bytesPerPixel = 4;
+    const BYTES_PER_PIXEL = 4;
     const pixelCount = imageData.width * imageData.height;
-    const bitmapBufferPtr = this.memoryManager.malloc(bytesPerPixel * pixelCount);
-    if (!bitmapBufferPtr) {
-      return false;
-    }
+    const bufPtr = this.memoryManager.malloc(BYTES_PER_PIXEL * pixelCount);
+    if (!bufPtr) return false;
     for (let i = 0; i < pixelCount; i++) {
-      const red = imageData.data[i * bytesPerPixel];
-      const green = imageData.data[i * bytesPerPixel + 1];
-      const blue = imageData.data[i * bytesPerPixel + 2];
-      const alpha = imageData.data[i * bytesPerPixel + 3];
-      this.pdfiumModule.pdfium.setValue(bitmapBufferPtr + i * bytesPerPixel, blue, "i8");
-      this.pdfiumModule.pdfium.setValue(bitmapBufferPtr + i * bytesPerPixel + 1, green, "i8");
-      this.pdfiumModule.pdfium.setValue(bitmapBufferPtr + i * bytesPerPixel + 2, red, "i8");
-      this.pdfiumModule.pdfium.setValue(bitmapBufferPtr + i * bytesPerPixel + 3, alpha, "i8");
-    }
-    const format = 4;
+      const r = imageData.data[i * 4 + 0];
+      const g = imageData.data[i * 4 + 1];
+      const b = imageData.data[i * 4 + 2];
+      const a = imageData.data[i * 4 + 3];
+      this.pdfiumModule.pdfium.setValue(bufPtr + i * 4 + 0, b, "i8");
+      this.pdfiumModule.pdfium.setValue(bufPtr + i * 4 + 1, g, "i8");
+      this.pdfiumModule.pdfium.setValue(bufPtr + i * 4 + 2, r, "i8");
+      this.pdfiumModule.pdfium.setValue(bufPtr + i * 4 + 3, a, "i8");
+    }
     const bitmapPtr = this.pdfiumModule.FPDFBitmap_CreateEx(
       imageData.width,
       imageData.height,
-      format,
-      bitmapBufferPtr,
+      4,
+      bufPtr,
       0
     );
     if (!bitmapPtr) {
-      this.memoryManager.free(bitmapBufferPtr);
-      return false;
-    }
-    const imageObjectPtr = this.pdfiumModule.FPDFPageObj_NewImageObj(docPtr);
-    if (!imageObjectPtr) {
-      this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
-      this.memoryManager.free(bitmapBufferPtr);
+      this.memoryManager.free(bufPtr);
       return false;
     }
-    if (!this.pdfiumModule.FPDFImageObj_SetBitmap(pagePtr, 0, imageObjectPtr, bitmapPtr)) {
+    const imgPtr = this.pdfiumModule.FPDFPageObj_NewImageObj(docPtr);
+    if (!imgPtr) {
       this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
-      this.pdfiumModule.FPDFPageObj_Destroy(imageObjectPtr);
-      this.memoryManager.free(bitmapBufferPtr);
+      this.memoryManager.free(bufPtr);
       return false;
     }
-    const matrixPtr = this.memoryManager.malloc(6 * 4);
-    this.pdfiumModule.pdfium.setValue(matrixPtr, imageData.width, "float");
-    this.pdfiumModule.pdfium.setValue(matrixPtr + 4, 0, "float");
-    this.pdfiumModule.pdfium.setValue(matrixPtr + 8, 0, "float");
-    this.pdfiumModule.pdfium.setValue(matrixPtr + 12, imageData.height, "float");
-    this.pdfiumModule.pdfium.setValue(matrixPtr + 16, 0, "float");
-    this.pdfiumModule.pdfium.setValue(matrixPtr + 20, 0, "float");
-    if (!this.pdfiumModule.FPDFPageObj_SetMatrix(imageObjectPtr, matrixPtr)) {
-      this.memoryManager.free(matrixPtr);
+    if (!this.pdfiumModule.FPDFImageObj_SetBitmap(pagePtr, 0, imgPtr, bitmapPtr)) {
+      this.pdfiumModule.FPDFPageObj_Destroy(imgPtr);
       this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
-      this.pdfiumModule.FPDFPageObj_Destroy(imageObjectPtr);
-      this.memoryManager.free(bitmapBufferPtr);
+      this.memoryManager.free(bufPtr);
       return false;
     }
-    this.memoryManager.free(matrixPtr);
-    const pagePos = this.convertDevicePointToPagePoint(page, {
-      x: rect.origin.x,
-      y: rect.origin.y + imageData.height
-      // shift down by the image height
-    });
-    this.pdfiumModule.FPDFPageObj_Transform(imageObjectPtr, 1, 0, 0, 1, pagePos.x, pagePos.y);
-    if (!this.pdfiumModule.FPDFAnnot_AppendObject(annotationPtr, imageObjectPtr)) {
+    const M = this.imageMatrixFromDeviceRect(page, rect);
+    const mPtr = this.memoryManager.malloc(6 * 4);
+    this.pdfiumModule.pdfium.setValue(mPtr + 0, M.a, "float");
+    this.pdfiumModule.pdfium.setValue(mPtr + 4, M.b, "float");
+    this.pdfiumModule.pdfium.setValue(mPtr + 8, M.c, "float");
+    this.pdfiumModule.pdfium.setValue(mPtr + 12, M.d, "float");
+    this.pdfiumModule.pdfium.setValue(mPtr + 16, M.e, "float");
+    this.pdfiumModule.pdfium.setValue(mPtr + 20, M.f, "float");
+    const setOk = this.pdfiumModule.FPDFPageObj_SetMatrix(imgPtr, mPtr);
+    this.memoryManager.free(mPtr);
+    if (!setOk) {
+      this.pdfiumModule.FPDFPageObj_Destroy(imgPtr);
       this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
-      this.pdfiumModule.FPDFPageObj_Destroy(imageObjectPtr);
-      this.memoryManager.free(bitmapBufferPtr);
+      this.memoryManager.free(bufPtr);
       return false;
     }
+    const ok = this.pdfiumModule.FPDFAnnot_AppendObject(annotationPtr, imgPtr);
     this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
-    this.memoryManager.free(bitmapBufferPtr);
-    return true;
+    this.memoryManager.free(bufPtr);
+    return !!ok;
   }
   /**
    * Save document to array buffer
@@ -4079,24 +4087,24 @@ class PdfiumEngine {
    * @param page - logical page info object (`PdfPageObject`)
    * @returns `{ start, end }` or `undefined` when PDFium can't read them
    */
-  getLinePoints(annotationPtr, page) {
-    const startPointPtr = this.memoryManager.malloc(8);
-    const endPointPtr = this.memoryManager.malloc(8);
-    this.pdfiumModule.FPDFAnnot_GetLine(annotationPtr, startPointPtr, endPointPtr);
-    const startPointX = this.pdfiumModule.pdfium.getValue(startPointPtr, "float");
-    const startPointY = this.pdfiumModule.pdfium.getValue(startPointPtr + 4, "float");
-    const start = this.convertPagePointToDevicePoint(page, {
-      x: startPointX,
-      y: startPointY
-    });
-    const endPointX = this.pdfiumModule.pdfium.getValue(endPointPtr, "float");
-    const endPointY = this.pdfiumModule.pdfium.getValue(endPointPtr + 4, "float");
-    const end = this.convertPagePointToDevicePoint(page, {
-      x: endPointX,
-      y: endPointY
-    });
-    this.memoryManager.free(startPointPtr);
-    this.memoryManager.free(endPointPtr);
+  getLinePoints(page, annotationPtr) {
+    const startPtr = this.memoryManager.malloc(8);
+    const endPtr = this.memoryManager.malloc(8);
+    const ok = this.pdfiumModule.FPDFAnnot_GetLine(annotationPtr, startPtr, endPtr);
+    if (!ok) {
+      this.memoryManager.free(startPtr);
+      this.memoryManager.free(endPtr);
+      return void 0;
+    }
+    const pdf = this.pdfiumModule.pdfium;
+    const sx = pdf.getValue(startPtr + 0, "float");
+    const sy = pdf.getValue(startPtr + 4, "float");
+    const ex = pdf.getValue(endPtr + 0, "float");
+    const ey = pdf.getValue(endPtr + 4, "float");
+    this.memoryManager.free(startPtr);
+    this.memoryManager.free(endPtr);
+    const start = this.convertPagePointToDevicePoint(page, { x: sx, y: sy });
+    const end = this.convertPagePointToDevicePoint(page, { x: ex, y: ey });
     return { start, end };
   }
   /**
@@ -4109,16 +4117,18 @@ class PdfiumEngine {
    * @returns true on success
    */
   setLinePoints(page, annotPtr, start, end) {
-    const buf = this.memoryManager.malloc(16);
     const p1 = this.convertDevicePointToPagePoint(page, start);
     const p2 = this.convertDevicePointToPagePoint(page, end);
-    this.pdfiumModule.pdfium.setValue(buf + 0, p1.x, "float");
-    this.pdfiumModule.pdfium.setValue(buf + 4, p1.y, "float");
-    this.pdfiumModule.pdfium.setValue(buf + 8, p2.x, "float");
-    this.pdfiumModule.pdfium.setValue(buf + 12, p2.y, "float");
+    if (!p1 || !p2) return false;
+    const buf = this.memoryManager.malloc(16);
+    const pdf = this.pdfiumModule.pdfium;
+    pdf.setValue(buf + 0, p1.x, "float");
+    pdf.setValue(buf + 4, p1.y, "float");
+    pdf.setValue(buf + 8, p2.x, "float");
+    pdf.setValue(buf + 12, p2.y, "float");
     const ok = this.pdfiumModule.EPDFAnnot_SetLine(annotPtr, buf, buf + 8);
     this.memoryManager.free(buf);
-    return ok;
+    return !!ok;
   }
   /**
    * Read `/QuadPoints` from any annotation and convert each quadrilateral to
@@ -4292,29 +4302,30 @@ class PdfiumEngine {
   /**
    * Read ink list from annotation
    * @param page  - logical page info object (`PdfPageObject`)
+   * @param pagePtr - pointer to the page
    * @param annotationPtr - pointer to the annotation whose ink list is needed
    * @returns ink list
    */
   getInkList(page, annotationPtr) {
     const inkList = [];
-    const count = this.pdfiumModule.FPDFAnnot_GetInkListCount(annotationPtr);
-    for (let i = 0; i < count; i++) {
+    const pathCount = this.pdfiumModule.FPDFAnnot_GetInkListCount(annotationPtr);
+    if (pathCount <= 0) return inkList;
+    const pdf = this.pdfiumModule.pdfium;
+    const POINT_STRIDE = 8;
+    for (let i = 0; i < pathCount; i++) {
       const points = [];
-      const pointsCount = this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, 0, 0);
-      if (pointsCount > 0) {
-        const pointMemorySize = 8;
-        const pointsPtr = this.memoryManager.malloc(pointsCount * pointMemorySize);
-        this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, pointsPtr, pointsCount);
-        for (let j = 0; j < pointsCount; j++) {
-          const pointX = this.pdfiumModule.pdfium.getValue(pointsPtr + j * 8, "float");
-          const pointY = this.pdfiumModule.pdfium.getValue(pointsPtr + j * 8 + 4, "float");
-          const { x, y } = this.convertPagePointToDevicePoint(page, {
-            x: pointX,
-            y: pointY
-          });
-          points.push({ x, y });
+      const n = this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, 0, 0);
+      if (n > 0) {
+        const buf = this.memoryManager.malloc(n * POINT_STRIDE);
+        this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, buf, n);
+        for (let j = 0; j < n; j++) {
+          const base = buf + j * POINT_STRIDE;
+          const px = pdf.getValue(base + 0, "float");
+          const py = pdf.getValue(base + 4, "float");
+          const d = this.convertPagePointToDevicePoint(page, { x: px, y: py });
+          points.push({ x: d.x, y: d.y });
         }
-        this.memoryManager.free(pointsPtr);
+        this.memoryManager.free(buf);
       }
       inkList.push({ points });
     }
@@ -4323,25 +4334,29 @@ class PdfiumEngine {
   /**
    * Add ink list to annotation
    * @param page  - logical page info object (`PdfPageObject`)
+   * @param pagePtr - pointer to the page
    * @param annotationPtr - pointer to the annotation whose ink list is needed
-   * @param annotation - annotation object (`PdfInkAnnoObject`)
+   * @param inkList - ink list array of `PdfInkListObject`
    * @returns `true` if the operation was successful
    */
   setInkList(page, annotationPtr, inkList) {
-    for (const inkStroke of inkList) {
-      const inkPointsCount = inkStroke.points.length;
-      const inkPointsPtr = this.memoryManager.malloc(inkPointsCount * 8);
-      for (let i = 0; i < inkPointsCount; i++) {
-        const point = inkStroke.points[i];
-        const { x, y } = this.convertDevicePointToPagePoint(page, point);
-        this.pdfiumModule.pdfium.setValue(inkPointsPtr + i * 8, x, "float");
-        this.pdfiumModule.pdfium.setValue(inkPointsPtr + i * 8 + 4, y, "float");
+    const pdf = this.pdfiumModule.pdfium;
+    const POINT_STRIDE = 8;
+    for (const stroke of inkList) {
+      const n = stroke.points.length;
+      if (n === 0) continue;
+      const buf = this.memoryManager.malloc(n * POINT_STRIDE);
+      for (let i = 0; i < n; i++) {
+        const pDev = stroke.points[i];
+        const pPage = this.convertDevicePointToPagePoint(page, pDev);
+        pdf.setValue(buf + i * POINT_STRIDE + 0, pPage.x, "float");
+        pdf.setValue(buf + i * POINT_STRIDE + 4, pPage.y, "float");
       }
-      if (this.pdfiumModule.FPDFAnnot_AddInkStroke(annotationPtr, inkPointsPtr, inkPointsCount) === -1) {
-        this.memoryManager.free(inkPointsPtr);
+      const idx = this.pdfiumModule.FPDFAnnot_AddInkStroke(annotationPtr, buf, n);
+      this.memoryManager.free(buf);
+      if (idx === -1) {
         return false;
       }
-      this.memoryManager.free(inkPointsPtr);
     }
     return true;
   }
@@ -4714,7 +4729,7 @@ class PdfiumEngine {
     const author = this.getAnnotString(annotationPtr, "T");
     const modified = this.getAnnotationDate(annotationPtr, "M");
     const created = this.getAnnotationDate(annotationPtr, "CreationDate");
-    const linePoints = this.getLinePoints(annotationPtr, page);
+    const linePoints = this.getLinePoints(page, annotationPtr);
     const lineEndings = this.getLineEndings(annotationPtr);
     const contents = this.getAnnotString(annotationPtr, "Contents") || "";
     const strokeColor = this.getAnnotationColor(annotationPtr);
@@ -5939,6 +5954,7 @@ class PdfiumEngine {
     const hDev = Math.max(1, Math.round((swap ? baseW : baseH) * finalScale));
     const stride = wDev * 4;
     const bytes = stride * hDev;
+    const pageCtx = ctx.acquirePage(page.index);
     const heapPtr = this.memoryManager.malloc(bytes);
     const bitmapPtr = this.pdfiumModule.FPDFBitmap_CreateEx(
       wDev,
@@ -5955,9 +5971,8 @@ class PdfiumEngine {
     const clipPtr = this.memoryManager.malloc(4 * 4);
     const clipView = new Float32Array(this.pdfiumModule.pdfium.HEAPF32.buffer, clipPtr, 4);
     clipView.set([0, 0, wDev, hDev]);
-    let flags = 2 | 16;
+    let flags = 16;
     if ((options == null ? void 0 : options.withAnnotations) ?? false) flags |= 1;
-    const pageCtx = ctx.acquirePage(page.index);
     try {
       this.pdfiumModule.FPDF_RenderPageBitmapWithMatrix(
         bitmapPtr,
@@ -5977,13 +5992,12 @@ class PdfiumEngine {
     };
     this.imageDataConverter(
       () => {
-        const rgba = new Uint8ClampedArray(
-          this.pdfiumModule.pdfium.HEAPU8.subarray(heapPtr, heapPtr + bytes)
-        );
+        const heapBuf = this.pdfiumModule.pdfium.HEAPU8.buffer;
+        const data = new Uint8ClampedArray(heapBuf, heapPtr, bytes);
         return {
           width: wDev,
           height: hDev,
-          data: rgba
+          data
         };
       },
       imageType,
@@ -6361,9 +6375,21 @@ class PdfiumEngine {
    * @private
    */
   convertDevicePointToPagePoint(page, position) {
-    const x = position.x;
-    const y = page.size.height - position.y;
-    return { x, y };
+    const DW = page.size.width;
+    const DH = page.size.height;
+    const r = page.rotation & 3;
+    if (r === 0) {
+      return { x: position.x, y: DH - position.y };
+    }
+    if (r === 1) {
+      return { x: position.y, y: position.x };
+    }
+    if (r === 2) {
+      return { x: DW - position.x, y: position.y };
+    }
+    {
+      return { x: DH - position.y, y: DW - position.x };
+    }
   }
   /**
    * Convert coordinate of point from page coordinate to device coordinate
@@ -6374,9 +6400,21 @@ class PdfiumEngine {
    * @private
    */
   convertPagePointToDevicePoint(page, position) {
-    const x = position.x;
-    const y = page.size.height - position.y;
-    return { x, y };
+    const DW = page.size.width;
+    const DH = page.size.height;
+    const r = page.rotation & 3;
+    if (r === 0) {
+      return { x: position.x, y: DH - position.y };
+    }
+    if (r === 1) {
+      return { x: position.y, y: position.x };
+    }
+    if (r === 2) {
+      return { x: DW - position.x, y: position.y };
+    }
+    {
+      return { x: DW - position.y, y: DH - position.x };
+    }
   }
   /**
    * Convert coordinate of rectangle from page coordinate to device coordinate
@@ -6466,40 +6504,30 @@ class PdfiumEngine {
    *
    * @private
    */
-  setPageAnnoRect(page, pagePtr, annotationPtr, rect) {
-    const pageXPtr = this.memoryManager.malloc(8);
-    const pageYPtr = this.memoryManager.malloc(8);
-    if (!this.pdfiumModule.FPDF_DeviceToPage(
-      pagePtr,
-      0,
-      0,
-      page.size.width,
-      page.size.height,
-      0,
-      rect.origin.x,
-      rect.origin.y,
-      pageXPtr,
-      pageYPtr
-    )) {
-      this.memoryManager.free(pageXPtr);
-      this.memoryManager.free(pageYPtr);
-      return false;
-    }
-    const pageX = this.pdfiumModule.pdfium.getValue(pageXPtr, "double");
-    const pageY = this.pdfiumModule.pdfium.getValue(pageYPtr, "double");
-    this.memoryManager.free(pageXPtr);
-    this.memoryManager.free(pageYPtr);
-    const pageRectPtr = this.memoryManager.malloc(4 * 4);
-    this.pdfiumModule.pdfium.setValue(pageRectPtr, pageX, "float");
-    this.pdfiumModule.pdfium.setValue(pageRectPtr + 4, pageY, "float");
-    this.pdfiumModule.pdfium.setValue(pageRectPtr + 8, pageX + rect.size.width, "float");
-    this.pdfiumModule.pdfium.setValue(pageRectPtr + 12, pageY - rect.size.height, "float");
-    if (!this.pdfiumModule.FPDFAnnot_SetRect(annotationPtr, pageRectPtr)) {
-      this.memoryManager.free(pageRectPtr);
-      return false;
-    }
-    this.memoryManager.free(pageRectPtr);
-    return true;
+  setPageAnnoRect(page, annotationPtr, rect) {
+    const x0 = rect.origin.x;
+    const y0 = rect.origin.y;
+    const x1 = x0 + rect.size.width;
+    const y1 = y0 + rect.size.height;
+    const p1 = this.convertDevicePointToPagePoint(page, { x: x0, y: y0 });
+    const p2 = this.convertDevicePointToPagePoint(page, { x: x1, y: y0 });
+    const p3 = this.convertDevicePointToPagePoint(page, { x: x1, y: y1 });
+    const p4 = this.convertDevicePointToPagePoint(page, { x: x0, y: y1 });
+    if (!p1 || !p2 || !p3 || !p4) return false;
+    const xs = [p1.x, p2.x, p3.x, p4.x];
+    const ys = [p1.y, p2.y, p3.y, p4.y];
+    const left = Math.min(...xs);
+    const right = Math.max(...xs);
+    const bottom = Math.min(...ys);
+    const top = Math.max(...ys);
+    const rectPtr = this.memoryManager.malloc(16);
+    this.pdfiumModule.pdfium.setValue(rectPtr + 0, left, "float");
+    this.pdfiumModule.pdfium.setValue(rectPtr + 4, bottom, "float");
+    this.pdfiumModule.pdfium.setValue(rectPtr + 8, right, "float");
+    this.pdfiumModule.pdfium.setValue(rectPtr + 12, top, "float");
+    const ok = this.pdfiumModule.FPDFAnnot_SetRect(annotationPtr, rectPtr);
+    this.memoryManager.free(rectPtr);
+    return !!ok;
   }
   /**
    * Read the rectangle of annotation
@@ -6536,62 +6564,39 @@ class PdfiumEngine {
    *
    * @private
    */
-  getHighlightRects(page, pagePtr, textPagePtr, startIndex, charCount) {
+  getHighlightRects(page, textPagePtr, startIndex, charCount) {
     const rectsCount = this.pdfiumModule.FPDFText_CountRects(textPagePtr, startIndex, charCount);
     const highlightRects = [];
+    const l = this.memoryManager.malloc(8);
+    const t = this.memoryManager.malloc(8);
+    const r = this.memoryManager.malloc(8);
+    const b = this.memoryManager.malloc(8);
     for (let i = 0; i < rectsCount; i++) {
-      const topPtr = this.memoryManager.malloc(8);
-      const leftPtr = this.memoryManager.malloc(8);
-      const rightPtr = this.memoryManager.malloc(8);
-      const bottomPtr = this.memoryManager.malloc(8);
-      const isSucceed = this.pdfiumModule.FPDFText_GetRect(
-        textPagePtr,
-        i,
-        leftPtr,
-        topPtr,
-        rightPtr,
-        bottomPtr
-      );
-      if (!isSucceed) {
-        this.memoryManager.free(leftPtr);
-        this.memoryManager.free(topPtr);
-        this.memoryManager.free(rightPtr);
-        this.memoryManager.free(bottomPtr);
-        continue;
-      }
-      const left = this.pdfiumModule.pdfium.getValue(leftPtr, "double");
-      const top = this.pdfiumModule.pdfium.getValue(topPtr, "double");
-      const right = this.pdfiumModule.pdfium.getValue(rightPtr, "double");
-      const bottom = this.pdfiumModule.pdfium.getValue(bottomPtr, "double");
-      this.memoryManager.free(leftPtr);
-      this.memoryManager.free(topPtr);
-      this.memoryManager.free(rightPtr);
-      this.memoryManager.free(bottomPtr);
-      const deviceXPtr = this.memoryManager.malloc(4);
-      const deviceYPtr = this.memoryManager.malloc(4);
-      this.pdfiumModule.FPDF_PageToDevice(
-        pagePtr,
-        0,
-        0,
-        page.size.width,
-        page.size.height,
-        0,
-        left,
-        top,
-        deviceXPtr,
-        deviceYPtr
-      );
-      const x = this.pdfiumModule.pdfium.getValue(deviceXPtr, "i32");
-      const y = this.pdfiumModule.pdfium.getValue(deviceYPtr, "i32");
-      this.memoryManager.free(deviceXPtr);
-      this.memoryManager.free(deviceYPtr);
-      const width = Math.ceil(Math.abs(right - left));
-      const height = Math.ceil(Math.abs(top - bottom));
+      const ok = this.pdfiumModule.FPDFText_GetRect(textPagePtr, i, l, t, r, b);
+      if (!ok) continue;
+      const left = this.pdfiumModule.pdfium.getValue(l, "double");
+      const top = this.pdfiumModule.pdfium.getValue(t, "double");
+      const right = this.pdfiumModule.pdfium.getValue(r, "double");
+      const bottom = this.pdfiumModule.pdfium.getValue(b, "double");
+      const p1 = this.convertPagePointToDevicePoint(page, { x: left, y: top });
+      const p2 = this.convertPagePointToDevicePoint(page, { x: right, y: top });
+      const p3 = this.convertPagePointToDevicePoint(page, { x: right, y: bottom });
+      const p4 = this.convertPagePointToDevicePoint(page, { x: left, y: bottom });
+      const xs = [p1.x, p2.x, p3.x, p4.x];
+      const ys = [p1.y, p2.y, p3.y, p4.y];
+      const x = Math.min(...xs);
+      const y = Math.min(...ys);
+      const width = Math.max(...xs) - x;
+      const height = Math.max(...ys) - y;
       highlightRects.push({
         origin: { x, y },
-        size: { width, height }
+        size: { width: Math.ceil(width), height: Math.ceil(height) }
       });
     }
+    this.memoryManager.free(l);
+    this.memoryManager.free(t);
+    this.memoryManager.free(r);
+    this.memoryManager.free(b);
     return highlightRects;
   }
   /**
@@ -6760,13 +6765,7 @@ class PdfiumEngine {
       while (this.pdfiumModule.FPDFText_FindNext(searchHandle)) {
         const charIndex = this.pdfiumModule.FPDFText_GetSchResultIndex(searchHandle);
         const charCount = this.pdfiumModule.FPDFText_GetSchCount(searchHandle);
-        const rects = this.getHighlightRects(
-          page,
-          pageCtx.pagePtr,
-          textPagePtr,
-          charIndex,
-          charCount
-        );
+        const rects = this.getHighlightRects(page, textPagePtr, charIndex, charCount);
         const context = this.buildContext(fullText, charIndex, charCount);
         pageResults.push({
           pageIndex: page.index,
@@ -7026,4 +7025,4 @@ export {
   isValidCustomKey as i,
   readString as r
 };
-//# sourceMappingURL=engine-BVe88qdX.js.map
+//# sourceMappingURL=engine-B2N46cyz.js.map