@embedpdf/engines 2.6.1 → 2.7.0

package/dist/{direct-engine-BmntIHbH.js → direct-engine-BfstxIRP.js}

@@ -1,6 +1,6 @@
 import { init } from "@embedpdf/pdfium";
-import { Rotation, NoopLogger, PdfTaskHelper, PdfErrorCode, pdfDateToDate, isUuidV4, uuidV4, PdfAnnotationSubtype, PdfPageFlattenFlag, stripPdfUnwantedMarkers, PdfAnnotationIcon, PdfAnnotationBorderStyle, PdfAnnotationColorType, PdfAnnotationLineEnding, PdfStandardFont, PdfStampFit, PdfTrappedStatus, pdfColorToWebColor, webColorToPdfColor, pdfAlphaToWebOpacity, webOpacityToPdfAlpha, PdfAnnotationReplyType, dateToPdfDate, quadToRect, rectToQuad, PdfPageObjectType, flagsToNames, namesToFlags, PDF_FORM_FIELD_TYPE, AppearanceMode, Task, toIntRect, transformRect, buildUserToDeviceMatrix, PdfZoomMode, PdfActionType } from "@embedpdf/models";
-import { P as PdfEngine } from "./pdf-engine-C07l7iNd.js";
+import { Rotation, NoopLogger, PdfTaskHelper, PdfErrorCode, pdfDateToDate, isUuidV4, uuidV4, PdfAnnotationSubtype, PdfPageFlattenFlag, stripPdfUnwantedMarkers, PdfAnnotationIcon, PdfAnnotationBorderStyle, PdfAnnotationColorType, PdfAnnotationLineEnding, PdfStandardFont, PdfStampFit, PdfTrappedStatus, pdfColorToWebColor, webColorToPdfColor, pdfAlphaToWebOpacity, webOpacityToPdfAlpha, PdfAnnotationReplyType, dateToPdfDate, quadToRect, rectToQuad, PdfPageObjectType, flagsToNames, namesToFlags, PDF_FORM_FIELD_TYPE, AppearanceMode, Task, toIntRect, transformRect, buildUserToDeviceMatrix, AP_MODE_NORMAL, AP_MODE_ROLLOVER, AP_MODE_DOWN, PdfZoomMode, PdfActionType } from "@embedpdf/models";
+import { P as PdfEngine } from "./pdf-engine-ZvReuoDb.js";
 import { b as browserImageDataToBlobConverter } from "./browser-BISJ9naB.js";
 function readString(wasmModule, readChars, parseChars, defaultLength = 100) {
   let buffer = wasmModule.wasmExports.malloc(defaultLength);
@@ -1704,7 +1704,7 @@ class PdfiumNative {
    *
    * @returns PdfTask<boolean>  –  true on success
    */
-  updatePageAnnotation(doc, page, annotation) {
+  updatePageAnnotation(doc, page, annotation, options) {
     this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "updatePageAnnotation", doc, page, annotation);
     this.logger.perf(
       LOG_SOURCE,
@@ -1873,7 +1873,7 @@ class PdfiumNative {
       default:
         ok = false;
     }
-    if (ok) {
+    if (ok && (options == null ? void 0 : options.regenerateAppearance) !== false) {
       if (annotation.blendMode !== void 0) {
         this.pdfiumModule.EPDFAnnot_GenerateAppearanceWithBlend(annotPtr, annotation.blendMode);
       } else {
@@ -3732,7 +3732,8 @@ class PdfiumNative {
             height: g.size.height
           },
           charStart: i,
-          glyphs: []
+          glyphs: [],
+          fontSize: this.pdfiumModule.FPDFText_GetFontSize(textPagePtr, i)
         };
         bounds = {
           minX: g.origin.x,
@@ -3747,7 +3748,9 @@ class PdfiumNative {
         y: g.origin.y,
         width: g.size.width,
         height: g.size.height,
-        flags: g.isEmpty ? 2 : g.isSpace ? 1 : 0
+        flags: g.isEmpty ? 2 : g.isSpace ? 1 : 0,
+        ...g.tightOrigin && { tightX: g.tightOrigin.x, tightY: g.tightOrigin.y },
+        ...g.tightSize && { tightWidth: g.tightSize.width, tightHeight: g.tightSize.height }
       });
       if (g.isEmpty) {
         continue;
@@ -3959,14 +3962,31 @@ class PdfiumNative {
     const dx2Ptr = this.memoryManager.malloc(4);
     const dy2Ptr = this.memoryManager.malloc(4);
     const rectPtr = this.memoryManager.malloc(16);
+    const tLeftPtr = this.memoryManager.malloc(8);
+    const tRightPtr = this.memoryManager.malloc(8);
+    const tBottomPtr = this.memoryManager.malloc(8);
+    const tTopPtr = this.memoryManager.malloc(8);
+    const allPtrs = [
+      rectPtr,
+      dx1Ptr,
+      dy1Ptr,
+      dx2Ptr,
+      dy2Ptr,
+      tLeftPtr,
+      tRightPtr,
+      tBottomPtr,
+      tTopPtr
+    ];
     let x = 0, y = 0, width = 0, height = 0, isSpace = false;
+    let tightOrigin;
+    let tightSize;
     if (this.pdfiumModule.FPDFText_GetLooseCharBox(textPagePtr, charIndex, rectPtr)) {
       const left = this.pdfiumModule.pdfium.getValue(rectPtr, "float");
       const top = this.pdfiumModule.pdfium.getValue(rectPtr + 4, "float");
       const right = this.pdfiumModule.pdfium.getValue(rectPtr + 8, "float");
       const bottom = this.pdfiumModule.pdfium.getValue(rectPtr + 12, "float");
       if (left === right || top === bottom) {
-        [rectPtr, dx1Ptr, dy1Ptr, dx2Ptr, dy2Ptr].forEach((p) => this.memoryManager.free(p));
+        allPtrs.forEach((p) => this.memoryManager.free(p));
         return {
           origin: { x: 0, y: 0 },
           size: { width: 0, height: 0 },
@@ -3979,7 +3999,6 @@ class PdfiumNative {
         0,
         page.size.width,
         page.size.height,
-        /*rotate=*/
         0,
         left,
         top,
@@ -3992,7 +4011,6 @@ class PdfiumNative {
         0,
         page.size.width,
         page.size.height,
-        /*rotate=*/
         0,
         right,
         bottom,
@@ -4007,13 +4025,61 @@ class PdfiumNative {
       y = Math.min(y1, y2);
       width = Math.max(1, Math.abs(x2 - x1));
       height = Math.max(1, Math.abs(y2 - y1));
+      if (this.pdfiumModule.FPDFText_GetCharBox(
+        textPagePtr,
+        charIndex,
+        tLeftPtr,
+        tRightPtr,
+        tBottomPtr,
+        tTopPtr
+      )) {
+        const tLeft = this.pdfiumModule.pdfium.getValue(tLeftPtr, "double");
+        const tRight = this.pdfiumModule.pdfium.getValue(tRightPtr, "double");
+        const tBottom = this.pdfiumModule.pdfium.getValue(tBottomPtr, "double");
+        const tTop = this.pdfiumModule.pdfium.getValue(tTopPtr, "double");
+        this.pdfiumModule.FPDF_PageToDevice(
+          pagePtr,
+          0,
+          0,
+          page.size.width,
+          page.size.height,
+          0,
+          tLeft,
+          tTop,
+          dx1Ptr,
+          dy1Ptr
+        );
+        this.pdfiumModule.FPDF_PageToDevice(
+          pagePtr,
+          0,
+          0,
+          page.size.width,
+          page.size.height,
+          0,
+          tRight,
+          tBottom,
+          dx2Ptr,
+          dy2Ptr
+        );
+        const tx1 = this.pdfiumModule.pdfium.getValue(dx1Ptr, "i32");
+        const ty1 = this.pdfiumModule.pdfium.getValue(dy1Ptr, "i32");
+        const tx2 = this.pdfiumModule.pdfium.getValue(dx2Ptr, "i32");
+        const ty2 = this.pdfiumModule.pdfium.getValue(dy2Ptr, "i32");
+        tightOrigin = { x: Math.min(tx1, tx2), y: Math.min(ty1, ty2) };
+        tightSize = {
+          width: Math.max(1, Math.abs(tx2 - tx1)),
+          height: Math.max(1, Math.abs(ty2 - ty1))
+        };
+      }
       const uc = this.pdfiumModule.FPDFText_GetUnicode(textPagePtr, charIndex);
       isSpace = uc === 32;
     }
-    [rectPtr, dx1Ptr, dy1Ptr, dx2Ptr, dy2Ptr].forEach((p) => this.memoryManager.free(p));
+    allPtrs.forEach((p) => this.memoryManager.free(p));
     return {
       origin: { x, y },
       size: { width, height },
+      ...tightOrigin && { tightOrigin },
+      ...tightSize && { tightSize },
       ...isSpace && { isSpace }
     };
   }
@@ -4326,6 +4392,10 @@ class PdfiumNative {
     }
     if (annotation) {
       annotation = this.reverseRotateAnnotationOnLoad(annotation);
+      const apModes = this.pdfiumModule.EPDFAnnot_GetAvailableAppearanceModes(annotationPtr);
+      if (apModes) {
+        annotation.appearanceModes = apModes;
+      }
     }
     return annotation;
   }
@@ -6987,6 +7057,150 @@ class PdfiumNative {
     this.memoryManager.free(heapPtr);
     return task;
   }
+  /**
+   * Batch-render all annotation appearance streams for a page in one call.
+   * Returns a map of annotation ID -> rendered appearances (Normal/Rollover/Down).
+   * Skips annotations that have rotation + unrotatedRect (EmbedPDF-rotated)
+   * and annotations without any appearance stream.
+   *
+   * @public
+   */
+  renderPageAnnotationsRaw(doc, page, options) {
+    const { scaleFactor = 1, rotation = Rotation.Degree0, dpr = 1 } = options ?? {};
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "renderPageAnnotationsRaw", doc, page, options);
+    this.logger.perf(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "RenderPageAnnotationsRaw",
+      "Begin",
+      `${doc.id}-${page.index}`
+    );
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      this.logger.perf(
+        LOG_SOURCE,
+        LOG_CATEGORY,
+        "RenderPageAnnotationsRaw",
+        "End",
+        `${doc.id}-${page.index}`
+      );
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const pageCtx = ctx.acquirePage(page.index);
+    const result = {};
+    const finalScale = Math.max(0.01, scaleFactor * dpr);
+    const annotCount = this.pdfiumModule.FPDFPage_GetAnnotCount(pageCtx.pagePtr);
+    for (let i = 0; i < annotCount; i++) {
+      const annotPtr = this.pdfiumModule.FPDFPage_GetAnnot(pageCtx.pagePtr, i);
+      if (!annotPtr) continue;
+      try {
+        const nm = this.getAnnotString(annotPtr, "NM");
+        if (!nm) continue;
+        const extRotation = this.getAnnotExtendedRotation(annotPtr);
+        if (extRotation !== 0) {
+          const unrotatedRaw = this.readAnnotUnrotatedRect(annotPtr);
+          if (unrotatedRaw) continue;
+        }
+        const apModes = this.pdfiumModule.EPDFAnnot_GetAvailableAppearanceModes(annotPtr);
+        if (!apModes) continue;
+        const appearances = {};
+        const modesToRender = [
+          { bit: AP_MODE_NORMAL, mode: AppearanceMode.Normal, key: "normal" },
+          { bit: AP_MODE_ROLLOVER, mode: AppearanceMode.Rollover, key: "rollover" },
+          { bit: AP_MODE_DOWN, mode: AppearanceMode.Down, key: "down" }
+        ];
+        for (const { bit, mode, key } of modesToRender) {
+          if (!(apModes & bit)) continue;
+          const rendered = this.renderSingleAnnotAppearance(
+            doc,
+            page,
+            pageCtx,
+            annotPtr,
+            mode,
+            rotation,
+            finalScale
+          );
+          if (rendered) {
+            appearances[key] = rendered;
+          }
+        }
+        if (appearances.normal || appearances.rollover || appearances.down) {
+          result[nm] = appearances;
+        }
+      } finally {
+        this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
+      }
+    }
+    pageCtx.release();
+    this.logger.perf(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "RenderPageAnnotationsRaw",
+      "End",
+      `${doc.id}-${page.index}`
+    );
+    const task = new Task();
+    task.resolve(result);
+    return task;
+  }
+  /**
+   * Render a single annotation's appearance for a given mode.
+   * Returns the image data and rect, or null on failure.
+   * @private
+   */
+  renderSingleAnnotAppearance(doc, page, pageCtx, annotPtr, mode, rotation, finalScale) {
+    const pageRect = this.readPageAnnoRect(annotPtr);
+    const annotRect = this.convertPageRectToDeviceRect(doc, page, pageRect);
+    const rect = toIntRect(annotRect);
+    const devRect = toIntRect(transformRect(page.size, rect, rotation, finalScale));
+    const wDev = Math.max(1, devRect.size.width);
+    const hDev = Math.max(1, devRect.size.height);
+    const stride = wDev * 4;
+    const bytes = stride * hDev;
+    const heapPtr = this.memoryManager.malloc(bytes);
+    const bitmapPtr = this.pdfiumModule.FPDFBitmap_CreateEx(
+      wDev,
+      hDev,
+      4,
+      heapPtr,
+      stride
+    );
+    this.pdfiumModule.FPDFBitmap_FillRect(bitmapPtr, 0, 0, wDev, hDev, 0);
+    const M = buildUserToDeviceMatrix(rect, rotation, wDev, hDev);
+    const mPtr = this.memoryManager.malloc(6 * 4);
+    const mView = new Float32Array(this.pdfiumModule.pdfium.HEAPF32.buffer, mPtr, 6);
+    mView.set([M.a, M.b, M.c, M.d, M.e, M.f]);
+    const FLAGS = 16;
+    let ok = false;
+    try {
+      ok = !!this.pdfiumModule.EPDF_RenderAnnotBitmap(
+        bitmapPtr,
+        pageCtx.pagePtr,
+        annotPtr,
+        mode,
+        mPtr,
+        FLAGS
+      );
+    } finally {
+      this.memoryManager.free(mPtr);
+      this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
+    }
+    if (!ok) {
+      this.memoryManager.free(heapPtr);
+      return null;
+    }
+    const data = this.pdfiumModule.pdfium.HEAPU8.subarray(heapPtr, heapPtr + bytes);
+    const imageData = {
+      data: new Uint8ClampedArray(data),
+      width: wDev,
+      height: hDev
+    };
+    this.memoryManager.free(heapPtr);
+    return { data: imageData, rect: annotRect };
+  }
   renderRectEncoded(doc, page, rect, options) {
     const task = new Task();
     const rotation = (options == null ? void 0 : options.rotation) ?? Rotation.Degree0;
@@ -8198,4 +8412,4 @@ export {
   isValidCustomKey as i,
   readArrayBuffer as r
 };
-//# sourceMappingURL=direct-engine-BmntIHbH.js.map
+//# sourceMappingURL=direct-engine-BfstxIRP.js.map