@embedpdf/engines 1.3.2 → 1.3.4

package/dist/{engine-BVe88qdX.js → engine-N_GwaBxA.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(
@@ -4079,24 +4083,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 +4113,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 +4298,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 +4330,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 +4725,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 +5950,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 +5967,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 +5988,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 +6371,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 +6396,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
@@ -6459,47 +6493,36 @@ class PdfiumEngine {
   /**
    * Set the rect of specified annotation
    * @param page - page info that the annotation is belonged to
-   * @param pagePtr - pointer of page object
    * @param annotationPtr - pointer to annotation object
    * @param rect - target rectangle
    * @returns whether the rect is setted
    *
    * @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, annotPtr, rect) {
+    const x0d = Math.floor(rect.origin.x);
+    const y0d = Math.floor(rect.origin.y);
+    const x1d = Math.floor(rect.origin.x + rect.size.width);
+    const y1d = Math.floor(rect.origin.y + rect.size.height);
+    const TL = this.convertDevicePointToPagePoint(page, { x: x0d, y: y0d });
+    const TR = this.convertDevicePointToPagePoint(page, { x: x1d, y: y0d });
+    const BR = this.convertDevicePointToPagePoint(page, { x: x1d, y: y1d });
+    const BL = this.convertDevicePointToPagePoint(page, { x: x0d, y: y1d });
+    let left = Math.min(TL.x, TR.x, BR.x, BL.x);
+    let right = Math.max(TL.x, TR.x, BR.x, BL.x);
+    let bottom = Math.min(TL.y, TR.y, BR.y, BL.y);
+    let top = Math.max(TL.y, TR.y, BR.y, BL.y);
+    if (left > right) [left, right] = [right, left];
+    if (bottom > top) [bottom, top] = [top, bottom];
+    const ptr = this.memoryManager.malloc(16);
+    const pdf = this.pdfiumModule.pdfium;
+    pdf.setValue(ptr + 0, left, "float");
+    pdf.setValue(ptr + 4, top, "float");
+    pdf.setValue(ptr + 8, right, "float");
+    pdf.setValue(ptr + 12, bottom, "float");
+    const ok = this.pdfiumModule.FPDFAnnot_SetRect(annotPtr, ptr);
+    this.memoryManager.free(ptr);
+    return !!ok;
   }
   /**
    * Read the rectangle of annotation
@@ -6536,62 +6559,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 +6760,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 +7020,4 @@ export {
   isValidCustomKey as i,
   readString as r
 };
-//# sourceMappingURL=engine-BVe88qdX.js.map
+//# sourceMappingURL=engine-N_GwaBxA.js.map