@embedpdf/engines 2.5.0 → 2.6.1

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

@@ -1,7 +1,7 @@
 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-aJNoNMbt.js";
-import { b as browserImageDataToBlobConverter } from "./browser-qfUHZxQ6.js";
+import { P as PdfEngine } from "./pdf-engine-C07l7iNd.js";
+import { b as browserImageDataToBlobConverter } from "./browser-BISJ9naB.js";
 function readString(wasmModule, readChars, parseChars, defaultLength = 100) {
   let buffer = wasmModule.wasmExports.malloc(defaultLength);
   for (let i = 0; i < defaultLength; i++) {
@@ -1567,10 +1567,17 @@ class PdfiumNative {
         message: "can not set the rect of the annotation"
       });
     }
+    const saveAnnotation = this.prepareAnnotationForSave(annotation);
     let isSucceed = false;
-    switch (annotation.type) {
+    switch (saveAnnotation.type) {
       case PdfAnnotationSubtype.INK:
-        isSucceed = this.addInkStroke(doc, page, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addInkStroke(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotationPtr,
+          saveAnnotation
+        );
         break;
       case PdfAnnotationSubtype.STAMP:
         isSucceed = this.addStampContent(
@@ -1579,26 +1586,50 @@ class PdfiumNative {
           page,
           pageCtx.pagePtr,
           annotationPtr,
-          annotation,
+          saveAnnotation,
           context == null ? void 0 : context.imageData
         );
         break;
       case PdfAnnotationSubtype.TEXT:
-        isSucceed = this.addTextContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addTextContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotationPtr,
+          saveAnnotation
+        );
         break;
       case PdfAnnotationSubtype.FREETEXT:
-        isSucceed = this.addFreeTextContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addFreeTextContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotationPtr,
+          saveAnnotation
+        );
         break;
       case PdfAnnotationSubtype.LINE:
-        isSucceed = this.addLineContent(doc, page, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addLineContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotationPtr,
+          saveAnnotation
+        );
         break;
       case PdfAnnotationSubtype.POLYLINE:
       case PdfAnnotationSubtype.POLYGON:
-        isSucceed = this.addPolyContent(doc, page, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addPolyContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotationPtr,
+          saveAnnotation
+        );
         break;
       case PdfAnnotationSubtype.CIRCLE:
       case PdfAnnotationSubtype.SQUARE:
-        isSucceed = this.addShapeContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addShapeContent(doc, page, pageCtx.pagePtr, annotationPtr, saveAnnotation);
         break;
       case PdfAnnotationSubtype.UNDERLINE:
       case PdfAnnotationSubtype.STRIKEOUT:
@@ -1609,14 +1640,27 @@ class PdfiumNative {
           page,
           pageCtx.pagePtr,
           annotationPtr,
-          annotation
+          saveAnnotation
         );
         break;
       case PdfAnnotationSubtype.LINK:
-        isSucceed = this.addLinkContent(ctx.docPtr, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addLinkContent(
+          doc,
+          page,
+          ctx.docPtr,
+          pageCtx.pagePtr,
+          annotationPtr,
+          saveAnnotation
+        );
         break;
       case PdfAnnotationSubtype.REDACT:
-        isSucceed = this.addRedactContent(doc, page, pageCtx.pagePtr, annotationPtr, annotation);
+        isSucceed = this.addRedactContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotationPtr,
+          saveAnnotation
+        );
         break;
     }
     if (!isSucceed) {
@@ -1711,43 +1755,81 @@ class PdfiumNative {
         message: "failed to move annotation"
       });
     }
+    const saveAnnotation = this.prepareAnnotationForSave(annotation);
     let ok = false;
-    switch (annotation.type) {
+    switch (saveAnnotation.type) {
       /* ── Ink ─────────────────────────────────────────────────────────────── */
       case PdfAnnotationSubtype.INK: {
         if (!this.pdfiumModule.FPDFAnnot_RemoveInkList(annotPtr)) break;
-        ok = this.addInkStroke(doc, page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addInkStroke(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Stamp ───────────────────────────────────────────────────────────── */
       case PdfAnnotationSubtype.STAMP: {
-        ok = this.addStampContent(doc, ctx.docPtr, page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addStampContent(
+          doc,
+          ctx.docPtr,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       case PdfAnnotationSubtype.TEXT: {
-        ok = this.addTextContent(page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addTextContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Free text ────────────────────────────────────────────────────────── */
       case PdfAnnotationSubtype.FREETEXT: {
-        ok = this.addFreeTextContent(page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addFreeTextContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Shape ───────────────────────────────────────────────────────────── */
       case PdfAnnotationSubtype.CIRCLE:
       case PdfAnnotationSubtype.SQUARE: {
-        ok = this.addShapeContent(page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addShapeContent(doc, page, pageCtx.pagePtr, annotPtr, saveAnnotation);
         break;
       }
       /* ── Line ─────────────────────────────────────────────────────────────── */
       case PdfAnnotationSubtype.LINE: {
-        ok = this.addLineContent(doc, page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addLineContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Polygon / Polyline ───────────────────────────────────────────────── */
       case PdfAnnotationSubtype.POLYGON:
       case PdfAnnotationSubtype.POLYLINE: {
-        ok = this.addPolyContent(doc, page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addPolyContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Text-markup family ──────────────────────────────────────────────── */
@@ -1755,17 +1837,36 @@ class PdfiumNative {
       case PdfAnnotationSubtype.UNDERLINE:
       case PdfAnnotationSubtype.STRIKEOUT:
       case PdfAnnotationSubtype.SQUIGGLY: {
-        ok = this.addTextMarkupContent(doc, page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addTextMarkupContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Link ─────────────────────────────────────────────────────────────── */
       case PdfAnnotationSubtype.LINK: {
-        ok = this.addLinkContent(ctx.docPtr, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addLinkContent(
+          doc,
+          page,
+          ctx.docPtr,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Redact ───────────────────────────────────────────────────────────── */
       case PdfAnnotationSubtype.REDACT: {
-        ok = this.addRedactContent(doc, page, pageCtx.pagePtr, annotPtr, annotation);
+        ok = this.addRedactContent(
+          doc,
+          page,
+          pageCtx.pagePtr,
+          annotPtr,
+          saveAnnotation
+        );
         break;
       }
       /* ── Unsupported edits – fall through to error ───────────────────────── */
@@ -2749,7 +2850,7 @@ class PdfiumNative {
    *
    * @private
    */
-  addTextContent(page, pagePtr, annotationPtr, annotation) {
+  addTextContent(doc, page, pagePtr, annotationPtr, annotation) {
     if (!this.setAnnotationIcon(annotationPtr, annotation.icon || PdfAnnotationIcon.Comment)) {
       return false;
     }
@@ -2764,7 +2865,7 @@ class PdfiumNative {
         return false;
       }
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add free text content to annotation
@@ -2776,7 +2877,7 @@ class PdfiumNative {
    *
    * @private
    */
-  addFreeTextContent(page, pagePtr, annotationPtr, annotation) {
+  addFreeTextContent(doc, page, pagePtr, annotationPtr, annotation) {
     if (!this.setBorderStyle(annotationPtr, PdfAnnotationBorderStyle.SOLID, 0)) {
       return false;
     }
@@ -2808,7 +2909,7 @@ class PdfiumNative {
     } else if (!this.setAnnotationColor(annotationPtr, bgColor ?? "#FFFFFF", PdfAnnotationColorType.Color)) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Set the rect of specified annotation
@@ -2834,7 +2935,7 @@ class PdfiumNative {
     if (!this.setAnnotationColor(annotationPtr, strokeColor, PdfAnnotationColorType.Color)) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add line content to annotation
@@ -2894,7 +2995,7 @@ class PdfiumNative {
     )) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add polygon or polyline content to annotation
@@ -2948,7 +3049,7 @@ class PdfiumNative {
     )) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add link content (action or destination) to a link annotation
@@ -2960,7 +3061,7 @@ class PdfiumNative {
    *
    * @private
    */
-  addLinkContent(docPtr, pagePtr, annotationPtr, annotation) {
+  addLinkContent(doc, page, docPtr, pagePtr, annotationPtr, annotation) {
     const style = annotation.strokeStyle ?? PdfAnnotationBorderStyle.UNDERLINE;
     const width = annotation.strokeWidth ?? 2;
     if (!this.setBorderStyle(annotationPtr, style, width)) {
@@ -2983,7 +3084,7 @@ class PdfiumNative {
         return false;
       }
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add shape content to annotation
@@ -2995,7 +3096,7 @@ class PdfiumNative {
    *
    * @private
    */
-  addShapeContent(page, pagePtr, annotationPtr, annotation) {
+  addShapeContent(doc, page, pagePtr, annotationPtr, annotation) {
     if (!this.setBorderStyle(annotationPtr, annotation.strokeStyle, annotation.strokeWidth)) {
       return false;
     }
@@ -3023,7 +3124,7 @@ class PdfiumNative {
     )) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add highlight content to annotation
@@ -3045,7 +3146,7 @@ class PdfiumNative {
     if (!this.setAnnotationColor(annotationPtr, strokeColor, PdfAnnotationColorType.Color)) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add content to redact annotation
@@ -3112,7 +3213,7 @@ class PdfiumNative {
     if (annotation.textAlign !== void 0 && !this.setAnnotationTextAlignment(annotationPtr, annotation.textAlign)) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
   /**
    * Add contents to stamp annotation
@@ -3142,10 +3243,10 @@ class PdfiumNative {
         return false;
       }
     }
-    if (!this.pdfiumModule.EPDFAnnot_UpdateAppearanceToRect(annotationPtr, PdfStampFit.Cover)) {
+    if (!this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation)) {
       return false;
     }
-    return this.applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation);
+    return !!this.pdfiumModule.EPDFAnnot_UpdateAppearanceToRect(annotationPtr, PdfStampFit.Cover);
   }
   /**
    * Add image object to annotation
@@ -3664,6 +3765,184 @@ class PdfiumNative {
     }
     return runs;
   }
+  /**
+   * Rich text runs: groups consecutive characters sharing the same
+   * text object, font, size, and fill color into structured segments
+   * with full font metadata and bounding boxes in PDF page coordinates.
+   *
+   * @public
+   */
+  getPageTextRuns(doc, page) {
+    const label = "getPageTextRuns";
+    this.logger.perf(LOG_SOURCE, LOG_CATEGORY, label, "Begin", doc.id);
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      this.logger.perf(LOG_SOURCE, LOG_CATEGORY, label, "End", doc.id);
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const pageCtx = ctx.acquirePage(page.index);
+    const textPagePtr = pageCtx.getTextPage();
+    const charCount = this.pdfiumModule.FPDFText_CountChars(textPagePtr);
+    const runs = [];
+    let runStart = 0;
+    let curObjPtr = null;
+    let curFont = null;
+    let curFontSize = 0;
+    let curColor = null;
+    let bounds = null;
+    const flushRun = (end) => {
+      if (curObjPtr === null || curFont === null || curColor === null || bounds === null) return;
+      const count = end - runStart;
+      if (count <= 0) return;
+      const bufPtr = this.memoryManager.malloc(2 * (count + 1));
+      this.pdfiumModule.FPDFText_GetText(textPagePtr, runStart, count, bufPtr);
+      const text = stripPdfUnwantedMarkers(this.pdfiumModule.pdfium.UTF16ToString(bufPtr));
+      this.memoryManager.free(bufPtr);
+      runs.push({
+        text,
+        rect: {
+          origin: { x: bounds.minX, y: bounds.minY },
+          size: {
+            width: Math.max(1, bounds.maxX - bounds.minX),
+            height: Math.max(1, bounds.maxY - bounds.minY)
+          }
+        },
+        font: curFont,
+        fontSize: curFontSize,
+        color: curColor,
+        charIndex: runStart,
+        charCount: count
+      });
+    };
+    const rPtr = this.memoryManager.malloc(4);
+    const gPtr = this.memoryManager.malloc(4);
+    const bPtr = this.memoryManager.malloc(4);
+    const aPtr = this.memoryManager.malloc(4);
+    const rectPtr = this.memoryManager.malloc(16);
+    const dx1Ptr = this.memoryManager.malloc(4);
+    const dy1Ptr = this.memoryManager.malloc(4);
+    const dx2Ptr = this.memoryManager.malloc(4);
+    const dy2Ptr = this.memoryManager.malloc(4);
+    const italicAnglePtr = this.memoryManager.malloc(4);
+    for (let i = 0; i < charCount; i++) {
+      const uc = this.pdfiumModule.FPDFText_GetUnicode(textPagePtr, i);
+      if (uc === 65534 || uc === 65533) continue;
+      const objPtr = this.pdfiumModule.FPDFText_GetTextObject(textPagePtr, i);
+      if (objPtr === 0) continue;
+      const fontSize = this.pdfiumModule.FPDFText_GetFontSize(textPagePtr, i);
+      this.pdfiumModule.FPDFText_GetFillColor(textPagePtr, i, rPtr, gPtr, bPtr, aPtr);
+      const red = this.pdfiumModule.pdfium.getValue(rPtr, "i32") & 255;
+      const green = this.pdfiumModule.pdfium.getValue(gPtr, "i32") & 255;
+      const blue = this.pdfiumModule.pdfium.getValue(bPtr, "i32") & 255;
+      const alpha = this.pdfiumModule.pdfium.getValue(aPtr, "i32") & 255;
+      const fontInfo = this.readFontInfoFromTextObject(objPtr, italicAnglePtr);
+      const needNewRun = curObjPtr === null || objPtr !== curObjPtr || fontInfo.name !== curFont.name || Math.abs(fontSize - curFontSize) > 0.01 || red !== curColor.red || green !== curColor.green || blue !== curColor.blue;
+      if (needNewRun) {
+        flushRun(i);
+        curObjPtr = objPtr;
+        curFont = fontInfo;
+        curFontSize = fontSize;
+        curColor = { red, green, blue, alpha };
+        runStart = i;
+        bounds = null;
+      }
+      if (this.pdfiumModule.FPDFText_GetLooseCharBox(textPagePtr, i, 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) {
+          this.pdfiumModule.FPDF_PageToDevice(
+            pageCtx.pagePtr,
+            0,
+            0,
+            page.size.width,
+            page.size.height,
+            0,
+            left,
+            top,
+            dx1Ptr,
+            dy1Ptr
+          );
+          this.pdfiumModule.FPDF_PageToDevice(
+            pageCtx.pagePtr,
+            0,
+            0,
+            page.size.width,
+            page.size.height,
+            0,
+            right,
+            bottom,
+            dx2Ptr,
+            dy2Ptr
+          );
+          const x1 = this.pdfiumModule.pdfium.getValue(dx1Ptr, "i32");
+          const y1 = this.pdfiumModule.pdfium.getValue(dy1Ptr, "i32");
+          const x2 = this.pdfiumModule.pdfium.getValue(dx2Ptr, "i32");
+          const y2 = this.pdfiumModule.pdfium.getValue(dy2Ptr, "i32");
+          const cx = Math.min(x1, x2);
+          const cy = Math.min(y1, y2);
+          const cw = Math.abs(x2 - x1);
+          const ch = Math.abs(y2 - y1);
+          if (bounds === null) {
+            bounds = { minX: cx, minY: cy, maxX: cx + cw, maxY: cy + ch };
+          } else {
+            bounds.minX = Math.min(bounds.minX, cx);
+            bounds.minY = Math.min(bounds.minY, cy);
+            bounds.maxX = Math.max(bounds.maxX, cx + cw);
+            bounds.maxY = Math.max(bounds.maxY, cy + ch);
+          }
+        }
+      }
+    }
+    flushRun(charCount);
+    [rPtr, gPtr, bPtr, aPtr, rectPtr, dx1Ptr, dy1Ptr, dx2Ptr, dy2Ptr, italicAnglePtr].forEach(
+      (p) => this.memoryManager.free(p)
+    );
+    pageCtx.release();
+    this.logger.perf(LOG_SOURCE, LOG_CATEGORY, label, "End", doc.id);
+    return PdfTaskHelper.resolve({ runs });
+  }
+  /**
+   * Read font metadata from a text object handle via FPDFFont_* APIs.
+   */
+  readFontInfoFromTextObject(textObjPtr, italicAnglePtr) {
+    const fontPtr = this.pdfiumModule.FPDFTextObj_GetFont(textObjPtr);
+    let name = "";
+    let familyName = "";
+    let weight = 400;
+    let italic = false;
+    let monospaced = false;
+    let embedded = false;
+    if (fontPtr) {
+      const nameLen = this.pdfiumModule.FPDFFont_GetBaseFontName(fontPtr, 0, 0);
+      if (nameLen > 0) {
+        const nameBuf = this.memoryManager.malloc(nameLen + 1);
+        this.pdfiumModule.FPDFFont_GetBaseFontName(fontPtr, nameBuf, nameLen + 1);
+        name = this.pdfiumModule.pdfium.UTF8ToString(nameBuf);
+        this.memoryManager.free(nameBuf);
+      }
+      const famLen = this.pdfiumModule.FPDFFont_GetFamilyName(fontPtr, 0, 0);
+      if (famLen > 0) {
+        const famBuf = this.memoryManager.malloc(famLen + 1);
+        this.pdfiumModule.FPDFFont_GetFamilyName(fontPtr, famBuf, famLen + 1);
+        familyName = this.pdfiumModule.pdfium.UTF8ToString(famBuf);
+        this.memoryManager.free(famBuf);
+      }
+      weight = this.pdfiumModule.FPDFFont_GetWeight(fontPtr);
+      embedded = this.pdfiumModule.FPDFFont_GetIsEmbedded(fontPtr) !== 0;
+      if (this.pdfiumModule.FPDFFont_GetItalicAngle(fontPtr, italicAnglePtr)) {
+        const angle = this.pdfiumModule.pdfium.getValue(italicAnglePtr, "i32");
+        italic = angle !== 0;
+      }
+      const flags = this.pdfiumModule.FPDFFont_GetFlags(fontPtr);
+      monospaced = (flags & 1) !== 0;
+    }
+    return { name, familyName, weight, italic, monospaced, embedded };
+  }
   /**
    * Extract glyph geometry + metadata for `charIndex`
    *
@@ -4045,8 +4324,62 @@ class PdfiumNative {
         }
         break;
     }
+    if (annotation) {
+      annotation = this.reverseRotateAnnotationOnLoad(annotation);
+    }
     return annotation;
   }
+  /**
+   * On load, if a vertex-type annotation has rotation metadata in EPDFCustom,
+   * reverse-rotate the PDF's physically rotated vertices by -rotation to recover
+   * the unrotated vertices for runtime editing.
+   */
+  reverseRotateAnnotationOnLoad(annotation) {
+    const rotation = annotation.rotation;
+    const unrotatedRect = annotation.unrotatedRect;
+    if (!rotation || rotation === 0 || !unrotatedRect) {
+      return annotation;
+    }
+    const center = {
+      x: unrotatedRect.origin.x + unrotatedRect.size.width / 2,
+      y: unrotatedRect.origin.y + unrotatedRect.size.height / 2
+    };
+    switch (annotation.type) {
+      case PdfAnnotationSubtype.INK: {
+        const ink = annotation;
+        const unrotatedInkList = ink.inkList.map((stroke) => ({
+          points: stroke.points.map((p) => this.rotatePointForSave(p, center, -rotation))
+        }));
+        return { ...ink, inkList: unrotatedInkList };
+      }
+      case PdfAnnotationSubtype.LINE: {
+        const line = annotation;
+        return {
+          ...line,
+          linePoints: {
+            start: this.rotatePointForSave(line.linePoints.start, center, -rotation),
+            end: this.rotatePointForSave(line.linePoints.end, center, -rotation)
+          }
+        };
+      }
+      case PdfAnnotationSubtype.POLYGON: {
+        const poly = annotation;
+        return {
+          ...poly,
+          vertices: poly.vertices.map((v) => this.rotatePointForSave(v, center, -rotation))
+        };
+      }
+      case PdfAnnotationSubtype.POLYLINE: {
+        const polyline = annotation;
+        return {
+          ...polyline,
+          vertices: polyline.vertices.map((v) => this.rotatePointForSave(v, center, -rotation))
+        };
+      }
+      default:
+        return annotation;
+    }
+  }
   /**
    * Return the colour stored directly in the annotation dictionary's `/C` entry.
    *
@@ -4139,6 +4472,125 @@ class PdfiumNative {
     const pdfOpacity = webOpacityToPdfAlpha(opacity);
     return this.pdfiumModule.EPDFAnnot_SetOpacity(annotationPtr, pdfOpacity & 255);
   }
+  /**
+   * Get the rotation angle (in degrees) from the annotation's /Rotate entry.
+   * Returns 0 if no rotation is set or on error.
+   *
+   * @param annotationPtr - pointer to the annotation
+   * @returns rotation in degrees (0 if not set)
+   */
+  getAnnotationRotation(annotationPtr) {
+    const rotationPtr = this.memoryManager.malloc(4);
+    const ok = this.pdfiumModule.EPDFAnnot_GetRotate(annotationPtr, rotationPtr);
+    if (!ok) {
+      this.memoryManager.free(rotationPtr);
+      return 0;
+    }
+    const rotation = this.pdfiumModule.pdfium.getValue(rotationPtr, "float");
+    this.memoryManager.free(rotationPtr);
+    return rotation;
+  }
+  /**
+   * Set the rotation angle (in degrees) on the annotation's /Rotate entry.
+   * A value of 0 removes the /Rotate key.
+   *
+   * @param annotationPtr - pointer to the annotation
+   * @param rotation - rotation in degrees (clockwise)
+   * @returns true on success
+   */
+  setAnnotationRotation(annotationPtr, rotation) {
+    return !!this.pdfiumModule.EPDFAnnot_SetRotate(annotationPtr, rotation);
+  }
+  /**
+   * Get the EmbedPDF extended rotation (in degrees) from the annotation's
+   * /EPDFRotate entry. Returns 0 if not set or on error.
+   *
+   * @param annotationPtr - pointer to the annotation
+   * @returns rotation in degrees (0 if not set)
+   */
+  getAnnotExtendedRotation(annotationPtr) {
+    const rotationPtr = this.memoryManager.malloc(4);
+    const ok = this.pdfiumModule.EPDFAnnot_GetExtendedRotation(annotationPtr, rotationPtr);
+    if (!ok) {
+      this.memoryManager.free(rotationPtr);
+      return 0;
+    }
+    const rotation = this.pdfiumModule.pdfium.getValue(rotationPtr, "float");
+    this.memoryManager.free(rotationPtr);
+    return rotation;
+  }
+  /**
+   * Set the EmbedPDF extended rotation (in degrees) on the annotation's
+   * /EPDFRotate entry. A value of 0 removes the key.
+   *
+   * @param annotationPtr - pointer to the annotation
+   * @param rotation - rotation in degrees
+   * @returns true on success
+   */
+  setAnnotExtendedRotation(annotationPtr, rotation) {
+    return !!this.pdfiumModule.EPDFAnnot_SetExtendedRotation(annotationPtr, rotation);
+  }
+  /**
+   * Read the EmbedPDF unrotated rect from the annotation's /EPDFUnrotatedRect
+   * entry. Returns the raw page-space rect (same format as `readPageAnnoRect`)
+   * or null if not set.
+   *
+   * @param annotationPtr - pointer to the annotation
+   * @returns raw `{ left, top, right, bottom }` in page coords, or null
+   */
+  readAnnotUnrotatedRect(annotationPtr) {
+    const rectPtr = this.memoryManager.malloc(4 * 4);
+    const ok = this.pdfiumModule.EPDFAnnot_GetUnrotatedRect(annotationPtr, rectPtr);
+    if (!ok) {
+      this.memoryManager.free(rectPtr);
+      return null;
+    }
+    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");
+    this.memoryManager.free(rectPtr);
+    if (left === 0 && top === 0 && right === 0 && bottom === 0) {
+      return null;
+    }
+    return { left, top, right, bottom };
+  }
+  /**
+   * Write the EmbedPDF unrotated rect (/EPDFUnrotatedRect) for an annotation.
+   * Accepts a device-space `Rect` and converts to page coordinates internally,
+   * following the same pattern as `setPageAnnoRect`.
+   *
+   * @param doc  - pdf document object
+   * @param page - pdf page object
+   * @param annotPtr - pointer to the annotation
+   * @param rect - device-space rect to store as the unrotated rect
+   * @returns true on success
+   */
+  setAnnotUnrotatedRect(doc, 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(doc, page, { x: x0d, y: y0d });
+    const TR = this.convertDevicePointToPagePoint(doc, page, { x: x1d, y: y0d });
+    const BR = this.convertDevicePointToPagePoint(doc, page, { x: x1d, y: y1d });
+    const BL = this.convertDevicePointToPagePoint(doc, 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.EPDFAnnot_SetUnrotatedRect(annotPtr, ptr);
+    this.memoryManager.free(ptr);
+    return !!ok;
+  }
   /**
    * Fetch the `/Q` text-alignment value from a **FreeText** annotation.
    *
@@ -4288,10 +4740,11 @@ class PdfiumNative {
    * @returns `true` on success
    */
   setAnnotationDefaultAppearance(annotationPtr, font, fontSize, color) {
+    const resolvedFont = font === PdfStandardFont.Unknown ? PdfStandardFont.Helvetica : font;
     const { red, green, blue } = webColorToPdfColor(color);
     return !!this.pdfiumModule.EPDFAnnot_SetDefaultAppearance(
       annotationPtr,
-      font,
+      resolvedFont,
       fontSize,
       red & 255,
       green & 255,
@@ -4745,7 +5198,7 @@ class PdfiumNative {
         ptr,
         count,
         recurseForms ? true : false,
-        drawBlackBoxes ? true : false
+        false
       );
     } finally {
       this.memoryManager.free(ptr);
@@ -4998,7 +5451,7 @@ class PdfiumNative {
       state,
       stateModel,
       icon,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5037,7 +5490,7 @@ class PdfiumNative {
       textAlign,
       defaultStyle,
       richContent,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5085,7 +5538,7 @@ class PdfiumNative {
       strokeWidth,
       strokeStyle,
       strokeDashArray,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5108,7 +5561,7 @@ class PdfiumNative {
       type: PdfAnnotationSubtype.WIDGET,
       rect,
       field,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5128,7 +5581,7 @@ class PdfiumNative {
       id: index,
       type: PdfAnnotationSubtype.FILEATTACHMENT,
       rect,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5162,7 +5615,7 @@ class PdfiumNative {
       opacity,
       strokeWidth: strokeWidth === 0 ? 1 : strokeWidth,
       inkList,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5211,7 +5664,7 @@ class PdfiumNative {
       strokeStyle,
       strokeDashArray,
       vertices,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5255,7 +5708,7 @@ class PdfiumNative {
       strokeDashArray,
       lineEndings,
       vertices,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5302,7 +5755,7 @@ class PdfiumNative {
         start: PdfAnnotationLineEnding.None,
         end: PdfAnnotationLineEnding.None
       },
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5332,7 +5785,7 @@ class PdfiumNative {
       color: strokeColor,
       // deprecated alias
       opacity,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5362,7 +5815,7 @@ class PdfiumNative {
       color: strokeColor,
       // deprecated alias
       opacity,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5392,7 +5845,7 @@ class PdfiumNative {
       color: strokeColor,
       // deprecated alias
       opacity,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5422,7 +5875,7 @@ class PdfiumNative {
       color: strokeColor,
       // deprecated alias
       opacity,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5442,7 +5895,7 @@ class PdfiumNative {
       id: index,
       type: PdfAnnotationSubtype.CARET,
       rect,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5485,7 +5938,7 @@ class PdfiumNative {
       fontSize: da == null ? void 0 : da.fontSize,
       fontColor: da == null ? void 0 : da.fontColor,
       textAlign,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5505,7 +5958,7 @@ class PdfiumNative {
       id: index,
       type: PdfAnnotationSubtype.STAMP,
       rect,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5768,7 +6221,7 @@ class PdfiumNative {
       strokeColor: strokeColor ?? "#FF0000",
       strokeStyle,
       ...strokeDashArray !== void 0 && { strokeDashArray },
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5808,7 +6261,7 @@ class PdfiumNative {
       strokeWidth,
       strokeStyle,
       ...strokeDashArray !== void 0 && { strokeDashArray },
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5829,7 +6282,7 @@ class PdfiumNative {
       id: index,
       type,
       rect,
-      ...this.readBaseAnnotationProperties(annotationPtr)
+      ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
   /**
@@ -5861,6 +6314,73 @@ class PdfiumNative {
     if (!parentPtr) return false;
     return this.pdfiumModule.EPDFAnnot_SetLinkedAnnot(annotationPtr, "IRT", parentPtr);
   }
+  /**
+   * Rotate a point around a center by the given angle in degrees.
+   * Used to rotate vertices for PDF storage.
+   */
+  rotatePointForSave(point, center, angleDegrees) {
+    const rad = angleDegrees * Math.PI / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const dx = point.x - center.x;
+    const dy = point.y - center.y;
+    return {
+      x: center.x + dx * cos - dy * sin,
+      y: center.y + dx * sin + dy * cos
+    };
+  }
+  /**
+   * Prepare an annotation for saving to PDF.
+   * For vertex types (ink, line, polygon, polyline) with rotation,
+   * physically rotates the vertices by +rotation so that other PDF viewers
+   * see the correct visual result. Our viewer reverse-rotates on load.
+   */
+  prepareAnnotationForSave(annotation) {
+    const rotation = annotation.rotation;
+    const unrotatedRect = annotation.unrotatedRect;
+    if (!rotation || rotation === 0 || !unrotatedRect) {
+      return annotation;
+    }
+    const center = {
+      x: unrotatedRect.origin.x + unrotatedRect.size.width / 2,
+      y: unrotatedRect.origin.y + unrotatedRect.size.height / 2
+    };
+    switch (annotation.type) {
+      case PdfAnnotationSubtype.INK: {
+        const ink = annotation;
+        const rotatedInkList = ink.inkList.map((stroke) => ({
+          points: stroke.points.map((p) => this.rotatePointForSave(p, center, rotation))
+        }));
+        return { ...ink, inkList: rotatedInkList };
+      }
+      case PdfAnnotationSubtype.LINE: {
+        const line = annotation;
+        return {
+          ...line,
+          linePoints: {
+            start: this.rotatePointForSave(line.linePoints.start, center, rotation),
+            end: this.rotatePointForSave(line.linePoints.end, center, rotation)
+          }
+        };
+      }
+      case PdfAnnotationSubtype.POLYGON: {
+        const poly = annotation;
+        return {
+          ...poly,
+          vertices: poly.vertices.map((v) => this.rotatePointForSave(v, center, rotation))
+        };
+      }
+      case PdfAnnotationSubtype.POLYLINE: {
+        const polyline = annotation;
+        return {
+          ...polyline,
+          vertices: polyline.vertices.map((v) => this.rotatePointForSave(v, center, rotation))
+        };
+      }
+      default:
+        return annotation;
+    }
+  }
   /**
    * Apply all base annotation properties from PdfAnnotationObjectBase.
    * The setInReplyToId and setReplyType functions handle clearing when undefined.
@@ -5870,7 +6390,7 @@ class PdfiumNative {
    * @param annotation - the annotation object containing properties to apply
    * @returns `true` on success
    */
-  applyBaseAnnotationProperties(pagePtr, annotationPtr, annotation) {
+  applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation) {
     if (!this.setAnnotString(annotationPtr, "T", annotation.author || "")) {
       return false;
     }
@@ -5892,11 +6412,32 @@ class PdfiumNative {
         return false;
       }
     }
-    if (annotation.custom) {
-      if (!this.setAnnotCustom(annotationPtr, annotation.custom)) {
+    const existingCustom = this.getAnnotCustom(annotationPtr) ?? {};
+    const customData = {
+      ...existingCustom,
+      ...annotation.custom ?? {}
+    };
+    delete customData.unrotatedRect;
+    delete customData.rotation;
+    const hasCustomData = Object.keys(customData).length > 0;
+    if (hasCustomData) {
+      if (!this.setAnnotCustom(annotationPtr, customData)) {
+        return false;
+      }
+    } else if (Object.keys(existingCustom).length > 0) {
+      if (!this.setAnnotCustom(annotationPtr, null)) {
         return false;
       }
     }
+    if (annotation.rotation !== void 0) {
+      const pdfRotation = annotation.rotation ? (360 - annotation.rotation) % 360 : 0;
+      this.setAnnotExtendedRotation(annotationPtr, pdfRotation);
+    }
+    if (annotation.unrotatedRect) {
+      this.setAnnotUnrotatedRect(doc, page, annotationPtr, annotation.unrotatedRect);
+    } else if (annotation.rotation && annotation.rotation !== 0) {
+      this.setAnnotUnrotatedRect(doc, page, annotationPtr, annotation.rect);
+    }
     if (!this.setInReplyToId(pagePtr, annotationPtr, annotation.inReplyToId)) {
       return false;
     }
@@ -5909,10 +6450,12 @@ class PdfiumNative {
    * Read all base annotation properties from PdfAnnotationObjectBase.
    * Returns an object that can be spread into the annotation return value.
    *
+   * @param doc - pdf document object
+   * @param page - pdf page object
    * @param annotationPtr - pointer to annotation object
    * @returns object with base annotation properties
    */
-  readBaseAnnotationProperties(annotationPtr) {
+  readBaseAnnotationProperties(doc, page, annotationPtr) {
     const author = this.getAnnotString(annotationPtr, "T");
     const contents = this.getAnnotString(annotationPtr, "Contents") || "";
     const modified = this.getAnnotationDate(annotationPtr, "M");
@@ -5921,6 +6464,10 @@ class PdfiumNative {
     const custom = this.getAnnotCustom(annotationPtr);
     const inReplyToId = this.getInReplyToId(annotationPtr);
     const replyType = this.getReplyType(annotationPtr);
+    const pdfRotation = this.getAnnotExtendedRotation(annotationPtr);
+    const rotation = pdfRotation !== 0 ? (360 - pdfRotation) % 360 : 0;
+    const rawUnrotatedRect = this.readAnnotUnrotatedRect(annotationPtr);
+    const unrotatedRect = rawUnrotatedRect ? this.convertPageRectToDeviceRect(doc, page, rawUnrotatedRect) : void 0;
     return {
       author,
       contents,
@@ -5931,7 +6478,9 @@ class PdfiumNative {
       // Only include IRT if present
       ...inReplyToId && { inReplyToId },
       // Only include RT if present and not the default (Reply)
-      ...replyType && replyType !== PdfAnnotationReplyType.Reply && { replyType }
+      ...replyType && replyType !== PdfAnnotationReplyType.Reply && { replyType },
+      ...rotation !== 0 && { rotation },
+      ...unrotatedRect !== void 0 && { unrotatedRect }
     };
   }
   /**
@@ -6359,7 +6908,9 @@ class PdfiumNative {
       return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "annotation not found" });
     }
     const finalScale = Math.max(0.01, scaleFactor * dpr);
-    const rect = toIntRect(annotation.rect);
+    const unrotated = !!(options == null ? void 0 : options.unrotated) && !!annotation.unrotatedRect;
+    const renderRect = unrotated ? annotation.unrotatedRect : annotation.rect;
+    const rect = toIntRect(renderRect);
     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);
@@ -6387,14 +6938,25 @@ class PdfiumNative {
     const FLAGS = 16;
     let ok = false;
     try {
-      ok = !!this.pdfiumModule.EPDF_RenderAnnotBitmap(
-        bitmapPtr,
-        pageCtx.pagePtr,
-        annotPtr,
-        mode,
-        mPtr,
-        FLAGS
-      );
+      if (unrotated) {
+        ok = !!this.pdfiumModule.EPDF_RenderAnnotBitmapUnrotated(
+          bitmapPtr,
+          pageCtx.pagePtr,
+          annotPtr,
+          mode,
+          mPtr,
+          FLAGS
+        );
+      } else {
+        ok = !!this.pdfiumModule.EPDF_RenderAnnotBitmap(
+          bitmapPtr,
+          pageCtx.pagePtr,
+          annotPtr,
+          mode,
+          mPtr,
+          FLAGS
+        );
+      }
     } finally {
       this.memoryManager.free(mPtr);
       this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
@@ -7104,7 +7666,7 @@ class PdfiumNative {
       right: 0,
       bottom: 0
     };
-    if (this.pdfiumModule.FPDFAnnot_GetRect(annotationPtr, pageRectPtr)) {
+    if (this.pdfiumModule.EPDFAnnot_GetRect(annotationPtr, pageRectPtr)) {
       pageRect.left = this.pdfiumModule.pdfium.getValue(pageRectPtr, "float");
       pageRect.top = this.pdfiumModule.pdfium.getValue(pageRectPtr + 4, "float");
       pageRect.right = this.pdfiumModule.pdfium.getValue(pageRectPtr + 8, "float");
@@ -7629,11 +8191,11 @@ export {
   PdfiumErrorCode as P,
   RenderFlag as R,
   PdfiumNative as a,
-  readArrayBuffer as b,
-  createPdfiumEngine as c,
-  computeFormDrawParams as d,
-  createNodeFontLoader as e,
+  createNodeFontLoader as b,
+  computeFormDrawParams as c,
+  createPdfiumEngine as d,
+  readString as e,
   isValidCustomKey as i,
-  readString as r
+  readArrayBuffer as r
 };
-//# sourceMappingURL=direct-engine-D8HGqcIt.js.map
+//# sourceMappingURL=direct-engine-BmntIHbH.js.map