@embedpdf/engines 1.0.12 → 1.0.14

package/dist/{engine-M0_XZhss.js → engine-O49988D4.js}

@@ -1,4 +1,4 @@
-import { NoopLogger, PdfTaskHelper, PdfErrorCode, Rotation, Task, PdfAnnotationSubtype, stripPdfUnwantedMarkers, PdfAnnotationBorderStyle, dateToPdfDate, PdfAnnotationColorType, PdfPageObjectType, pdfAlphaColorToWebAlphaColor, webAlphaColorToPdfAlphaColor, quadToRect, pdfDateToDate, flagsToNames, PDF_FORM_FIELD_TYPE, AppearanceMode, toIntRect, transformRect, makeMatrix, toIntSize, transformSize, PdfActionType, PdfZoomMode, MatchFlag, rectToQuad } from "@embedpdf/models";
+import { NoopLogger, PdfTaskHelper, PdfErrorCode, Rotation, Task, PdfAnnotationSubtype, stripPdfUnwantedMarkers, PdfAnnotationBorderStyle, dateToPdfDate, PdfAnnotationColorType, PdfAnnotationLineEnding, PdfPageObjectType, pdfColorToWebColor, webColorToPdfColor, pdfAlphaToWebOpacity, webOpacityToPdfAlpha, quadToRect, pdfDateToDate, PdfStandardFont, flagsToNames, namesToFlags, PDF_FORM_FIELD_TYPE, AppearanceMode, toIntRect, transformRect, makeMatrix, toIntSize, transformSize, PdfActionType, PdfZoomMode, MatchFlag, rectToQuad } from "@embedpdf/models";
 function readString(wasmModule, readChars, parseChars, defaultLength = 100) {
   let buffer = wasmModule.wasmExports.malloc(defaultLength);
   for (let i = 0; i < defaultLength; i++) {
@@ -982,6 +982,20 @@ class PdfiumEngine {
           annotation.contents
         );
         break;
+      case PdfAnnotationSubtype.FREETEXT:
+        isSucceed = this.addFreeTextContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+        break;
+      case PdfAnnotationSubtype.LINE:
+        isSucceed = this.addLineContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+        break;
+      case PdfAnnotationSubtype.POLYLINE:
+      case PdfAnnotationSubtype.POLYGON:
+        isSucceed = this.addPolyContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+        break;
+      case PdfAnnotationSubtype.CIRCLE:
+      case PdfAnnotationSubtype.SQUARE:
+        isSucceed = this.addShapeContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+        break;
       case PdfAnnotationSubtype.UNDERLINE:
       case PdfAnnotationSubtype.STRIKEOUT:
       case PdfAnnotationSubtype.SQUIGGLY:
@@ -1108,6 +1122,28 @@ class PdfiumEngine {
         );
         break;
       }
+      /* ── Free text ────────────────────────────────────────────────────────── */
+      case PdfAnnotationSubtype.FREETEXT: {
+        ok = this.addFreeTextContent(page, pageCtx.pagePtr, annotPtr, annotation);
+        break;
+      }
+      /* ── Shape ───────────────────────────────────────────────────────────── */
+      case PdfAnnotationSubtype.CIRCLE:
+      case PdfAnnotationSubtype.SQUARE: {
+        ok = this.addShapeContent(page, pageCtx.pagePtr, annotPtr, annotation);
+        break;
+      }
+      /* ── Line ─────────────────────────────────────────────────────────────── */
+      case PdfAnnotationSubtype.LINE: {
+        ok = this.addLineContent(page, pageCtx.pagePtr, annotPtr, annotation);
+        break;
+      }
+      /* ── Polygon / Polyline ───────────────────────────────────────────────── */
+      case PdfAnnotationSubtype.POLYGON:
+      case PdfAnnotationSubtype.POLYLINE: {
+        ok = this.addPolyContent(page, pageCtx.pagePtr, annotPtr, annotation);
+        break;
+      }
       /* ── Text-markup family ──────────────────────────────────────────────── */
       case PdfAnnotationSubtype.HIGHLIGHT:
       case PdfAnnotationSubtype.UNDERLINE:
@@ -1892,6 +1928,55 @@ class PdfiumEngine {
   free(ptr) {
     this.pdfiumModule.pdfium.wasmExports.free(ptr);
   }
+  addFreeTextContent(page, pagePtr, annotationPtr, annotation) {
+    if (!this.setBorderStyle(annotationPtr, PdfAnnotationBorderStyle.SOLID, 0)) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "Contents", annotation.contents ?? "")) {
+      return false;
+    }
+    if (!this.setPageAnnoRect(page, pagePtr, annotationPtr, annotation.rect)) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "T", annotation.author || "")) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "M", dateToPdfDate(annotation.modified))) {
+      return false;
+    }
+    if (!this.setAnnotationOpacity(annotationPtr, annotation.opacity ?? 1)) {
+      return false;
+    }
+    if (!this.setAnnotationTextAlignment(annotationPtr, annotation.textAlign)) {
+      return false;
+    }
+    if (!this.setAnnotationVerticalAlignment(annotationPtr, annotation.verticalAlign)) {
+      return false;
+    }
+    if (!this.setAnnotationDefaultAppearance(
+      annotationPtr,
+      annotation.fontFamily,
+      annotation.fontSize,
+      annotation.fontColor
+    )) {
+      return false;
+    }
+    if (annotation.intent && !this.setAnnotIntent(annotationPtr, annotation.intent)) {
+      return false;
+    }
+    if (!annotation.backgroundColor || annotation.backgroundColor === "transparent") {
+      if (!this.pdfiumModule.EPDFAnnot_ClearColor(annotationPtr, PdfAnnotationColorType.Color)) {
+        return false;
+      }
+    } else if (!this.setAnnotationColor(
+      annotationPtr,
+      annotation.backgroundColor ?? "#FFFFFF",
+      PdfAnnotationColorType.Color
+    )) {
+      return false;
+    }
+    return true;
+  }
   /**
    * Set the rect of specified annotation
    * @param page - page info that the annotation is belonged to
@@ -1918,12 +2003,204 @@ class PdfiumEngine {
     if (!this.setAnnotString(annotationPtr, "M", dateToPdfDate(annotation.modified))) {
       return false;
     }
+    if (!this.setAnnotationOpacity(annotationPtr, annotation.opacity ?? 1)) {
+      return false;
+    }
     if (!this.setAnnotationColor(
       annotationPtr,
-      {
-        color: annotation.color ?? "#FFFF00",
-        opacity: annotation.opacity ?? 1
-      },
+      annotation.color ?? "#FFFF00",
+      PdfAnnotationColorType.Color
+    )) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Add line content to annotation
+   * @param page - page info
+   * @param pagePtr - pointer to page object
+   * @param annotationPtr - pointer to line annotation
+   * @param annotation - line annotation
+   * @returns whether line content is added to annotation
+   *
+   * @private
+   */
+  addLineContent(page, pagePtr, annotationPtr, annotation) {
+    var _a, _b;
+    if (!this.setPageAnnoRect(page, pagePtr, annotationPtr, annotation.rect)) {
+      return false;
+    }
+    if (!this.setLinePoints(
+      page,
+      annotationPtr,
+      annotation.linePoints.start,
+      annotation.linePoints.end
+    )) {
+      return false;
+    }
+    if (!this.setLineEndings(
+      annotationPtr,
+      ((_a = annotation.lineEndings) == null ? void 0 : _a.start) ?? PdfAnnotationLineEnding.None,
+      ((_b = annotation.lineEndings) == null ? void 0 : _b.end) ?? PdfAnnotationLineEnding.None
+    )) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "Contents", annotation.contents ?? "")) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "T", annotation.author || "")) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "M", dateToPdfDate(annotation.modified))) {
+      return false;
+    }
+    if (!this.setBorderStyle(annotationPtr, annotation.strokeStyle, annotation.strokeWidth)) {
+      return false;
+    }
+    if (!this.setBorderDashPattern(annotationPtr, annotation.strokeDashArray ?? [])) {
+      return false;
+    }
+    if (annotation.intent && !this.setAnnotIntent(annotationPtr, annotation.intent)) {
+      return false;
+    }
+    if (!annotation.color || annotation.color === "transparent") {
+      if (!this.pdfiumModule.EPDFAnnot_ClearColor(annotationPtr, PdfAnnotationColorType.InteriorColor)) {
+        return false;
+      }
+    } else if (!this.setAnnotationColor(
+      annotationPtr,
+      annotation.color ?? "#FFFF00",
+      PdfAnnotationColorType.InteriorColor
+    )) {
+      return false;
+    }
+    if (!this.setAnnotationOpacity(annotationPtr, annotation.opacity ?? 1)) {
+      return false;
+    }
+    if (!this.setAnnotationColor(
+      annotationPtr,
+      annotation.strokeColor ?? "#FFFF00",
+      PdfAnnotationColorType.Color
+    )) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Add polygon or polyline content to annotation
+   * @param page - page info
+   * @param pagePtr - pointer to page object
+   * @param annotationPtr - pointer to polygon or polyline annotation
+   * @param annotation - polygon or polyline annotation
+   * @returns whether polygon or polyline content is added to annotation
+   *
+   * @private
+   */
+  addPolyContent(page, pagePtr, annotationPtr, annotation) {
+    var _a, _b;
+    if (!this.setPageAnnoRect(page, pagePtr, annotationPtr, annotation.rect)) {
+      return false;
+    }
+    if (annotation.type === PdfAnnotationSubtype.POLYLINE && !this.setLineEndings(
+      annotationPtr,
+      ((_a = annotation.lineEndings) == null ? void 0 : _a.start) ?? PdfAnnotationLineEnding.None,
+      ((_b = annotation.lineEndings) == null ? void 0 : _b.end) ?? PdfAnnotationLineEnding.None
+    )) {
+      return false;
+    }
+    if (!this.setPdfAnnoVertices(page, annotationPtr, annotation.vertices)) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "Contents", annotation.contents ?? "")) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "T", annotation.author || "")) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "M", dateToPdfDate(annotation.modified))) {
+      return false;
+    }
+    if (!this.setBorderStyle(annotationPtr, annotation.strokeStyle, annotation.strokeWidth)) {
+      return false;
+    }
+    if (!this.setBorderDashPattern(annotationPtr, annotation.strokeDashArray ?? [])) {
+      return false;
+    }
+    if (annotation.intent && !this.setAnnotIntent(annotationPtr, annotation.intent)) {
+      return false;
+    }
+    if (!annotation.color || annotation.color === "transparent") {
+      if (!this.pdfiumModule.EPDFAnnot_ClearColor(annotationPtr, PdfAnnotationColorType.InteriorColor)) {
+        return false;
+      }
+    } else if (!this.setAnnotationColor(
+      annotationPtr,
+      annotation.color ?? "#FFFF00",
+      PdfAnnotationColorType.InteriorColor
+    )) {
+      return false;
+    }
+    if (!this.setAnnotationOpacity(annotationPtr, annotation.opacity ?? 1)) {
+      return false;
+    }
+    if (!this.setAnnotationColor(
+      annotationPtr,
+      annotation.strokeColor ?? "#FFFF00",
+      PdfAnnotationColorType.Color
+    )) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Add shape content to annotation
+   * @param page - page info
+   * @param pagePtr - pointer to page object
+   * @param annotationPtr - pointer to shape annotation
+   * @param annotation - shape annotation
+   * @returns whether shape content is added to annotation
+   *
+   * @private
+   */
+  addShapeContent(page, pagePtr, annotationPtr, annotation) {
+    if (!this.setPageAnnoRect(page, pagePtr, annotationPtr, annotation.rect)) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "Contents", annotation.contents ?? "")) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "T", annotation.author || "")) {
+      return false;
+    }
+    if (!this.setAnnotString(annotationPtr, "M", dateToPdfDate(annotation.modified))) {
+      return false;
+    }
+    if (!this.setBorderStyle(annotationPtr, annotation.strokeStyle, annotation.strokeWidth)) {
+      return false;
+    }
+    if (!this.setBorderDashPattern(annotationPtr, annotation.strokeDashArray ?? [])) {
+      return false;
+    }
+    if (!this.setAnnotationFlags(annotationPtr, annotation.flags)) {
+      return false;
+    }
+    if (!annotation.color || annotation.color === "transparent") {
+      if (!this.pdfiumModule.EPDFAnnot_ClearColor(annotationPtr, PdfAnnotationColorType.InteriorColor)) {
+        return false;
+      }
+    } else if (!this.setAnnotationColor(
+      annotationPtr,
+      annotation.color ?? "#FFFF00",
+      PdfAnnotationColorType.InteriorColor
+    )) {
+      return false;
+    }
+    if (!this.setAnnotationOpacity(annotationPtr, annotation.opacity ?? 1)) {
+      return false;
+    }
+    if (!this.setAnnotationColor(
+      annotationPtr,
+      annotation.strokeColor ?? "#FFFF00",
       PdfAnnotationColorType.Color
     )) {
       return false;
@@ -1955,12 +2232,12 @@ class PdfiumEngine {
     if (!this.setAnnotString(annotationPtr, "M", dateToPdfDate(annotation.modified))) {
       return false;
     }
+    if (!this.setAnnotationOpacity(annotationPtr, annotation.opacity ?? 1)) {
+      return false;
+    }
     if (!this.setAnnotationColor(
       annotationPtr,
-      {
-        color: annotation.color ?? "#FFFF00",
-        opacity: annotation.opacity ?? 1
-      },
+      annotation.color ?? "#FFFF00",
       PdfAnnotationColorType.Color
     )) {
       return false;
@@ -2724,50 +3001,32 @@ class PdfiumEngine {
     const rPtr = this.malloc(4);
     const gPtr = this.malloc(4);
     const bPtr = this.malloc(4);
-    const aPtr = this.malloc(4);
-    const ok = this.pdfiumModule.EPDFAnnot_GetColor(
-      annotationPtr,
-      colorType,
-      rPtr,
-      gPtr,
-      bPtr,
-      aPtr
-    );
+    const ok = this.pdfiumModule.EPDFAnnot_GetColor(annotationPtr, colorType, rPtr, gPtr, bPtr);
     let colour;
     if (ok) {
       colour = {
         red: this.pdfiumModule.pdfium.getValue(rPtr, "i32") & 255,
         green: this.pdfiumModule.pdfium.getValue(gPtr, "i32") & 255,
-        blue: this.pdfiumModule.pdfium.getValue(bPtr, "i32") & 255,
-        alpha: this.pdfiumModule.pdfium.getValue(aPtr, "i32") & 255
-        // 0 = transparent, 255 = opaque
+        blue: this.pdfiumModule.pdfium.getValue(bPtr, "i32") & 255
       };
     }
     this.free(rPtr);
     this.free(gPtr);
     this.free(bPtr);
-    this.free(aPtr);
     return colour;
   }
-  /* --------------------------------------------------------------------------- */
   /**
-   * Resolve the visible fill colour for **Highlight / Underline / StrikeOut /
-   * Squiggly** markup annotations.
-   *
-   * Resolution order (first non-`undefined` wins):
-   *  1. `/C` dictionary entry – fast, present in Acrobat / Office PDFs
-   *  2. Appearance-stream objects – drills into paths & nested forms
-   *  3. Hard-coded fallback (Acrobat-style opaque yellow)
+   * Get the fill/stroke colour annotation.
    *
-   * @param annotationPtr - pointer to an `FPDF_ANNOTATION`
-   * @param fallback      - colour to use when the PDF stores no tint at all
-   * @returns WebAlphaColor with hex color and opacity (0-1)
+   * @param annotationPtr - pointer to the annotation whose colour is being set
+   * @param colorType - which colour to get (0 = fill, 1 = stroke)
+   * @returns WebColor with hex color
    *
    * @private
    */
-  resolveAnnotationColor(annotationPtr, colorType = PdfAnnotationColorType.Color, fallback = { red: 255, green: 245, blue: 155, alpha: 255 }) {
-    const pdfColor = this.readAnnotationColor(annotationPtr, colorType) ?? fallback;
-    return pdfAlphaColorToWebAlphaColor(pdfColor);
+  getAnnotationColor(annotationPtr, colorType = PdfAnnotationColorType.Color) {
+    const annotationColor = this.readAnnotationColor(annotationPtr, colorType);
+    return annotationColor ? pdfColorToWebColor(annotationColor) : void 0;
   }
   /**
    * Set the fill/stroke colour for a **Highlight / Underline / StrikeOut / Squiggly** markup annotation.
@@ -2780,15 +3039,143 @@ class PdfiumEngine {
    *
    * @private
    */
-  setAnnotationColor(annotationPtr, webAlphaColor, colorType = PdfAnnotationColorType.Color) {
-    const pdfAlphaColor = webAlphaColorToPdfAlphaColor(webAlphaColor);
+  setAnnotationColor(annotationPtr, webColor, colorType = PdfAnnotationColorType.Color) {
+    const pdfColor = webColorToPdfColor(webColor);
     return this.pdfiumModule.EPDFAnnot_SetColor(
       annotationPtr,
       colorType,
-      pdfAlphaColor.red & 255,
-      pdfAlphaColor.green & 255,
-      pdfAlphaColor.blue & 255,
-      (pdfAlphaColor.alpha ?? 255) & 255
+      pdfColor.red & 255,
+      pdfColor.green & 255,
+      pdfColor.blue & 255
+    );
+  }
+  /**
+   * Get the opacity of the annotation.
+   *
+   * @param annotationPtr - pointer to the annotation whose opacity is being set
+   * @returns opacity (0-1)
+   *
+   * @private
+   */
+  getAnnotationOpacity(annotationPtr) {
+    const opacityPtr = this.malloc(4);
+    const ok = this.pdfiumModule.EPDFAnnot_GetOpacity(annotationPtr, opacityPtr);
+    const opacity = ok ? this.pdfiumModule.pdfium.getValue(opacityPtr, "i32") : 255;
+    this.free(opacityPtr);
+    return pdfAlphaToWebOpacity(opacity);
+  }
+  /**
+   * Set the opacity of the annotation.
+   *
+   * @param annotationPtr - pointer to the annotation whose opacity is being set
+   * @param opacity - opacity (0-1)
+   * @returns true on success
+   *
+   * @private
+   */
+  setAnnotationOpacity(annotationPtr, opacity) {
+    const pdfOpacity = webOpacityToPdfAlpha(opacity);
+    return this.pdfiumModule.EPDFAnnot_SetOpacity(annotationPtr, pdfOpacity & 255);
+  }
+  /**
+   * Fetch the `/Q` text-alignment value from a **FreeText** annotation.
+   *
+   * @param annotationPtr pointer returned by `FPDFPage_GetAnnot`
+   * @returns `PdfTextAlignment`
+   */
+  getAnnotationTextAlignment(annotationPtr) {
+    return this.pdfiumModule.EPDFAnnot_GetTextAlignment(annotationPtr);
+  }
+  /**
+   * Write the `/Q` text-alignment value into a **FreeText** annotation
+   * and clear the existing appearance stream so it can be regenerated.
+   *
+   * @param annotationPtr pointer returned by `FPDFPage_GetAnnot`
+   * @param alignment     `PdfTextAlignment`
+   * @returns `true` on success
+   */
+  setAnnotationTextAlignment(annotationPtr, alignment) {
+    return !!this.pdfiumModule.EPDFAnnot_SetTextAlignment(annotationPtr, alignment);
+  }
+  /**
+   * Fetch the `/EPDF:VerticalAlignment` vertical-alignment value from a **FreeText** annotation.
+   *
+   * @param annotationPtr pointer returned by `FPDFPage_GetAnnot`
+   * @returns `PdfVerticalAlignment`
+   */
+  getAnnotationVerticalAlignment(annotationPtr) {
+    return this.pdfiumModule.EPDFAnnot_GetVerticalAlignment(annotationPtr);
+  }
+  /**
+   * Write the `/EPDF:VerticalAlignment` vertical-alignment value into a **FreeText** annotation
+   * and clear the existing appearance stream so it can be regenerated.
+   *
+   * @param annotationPtr pointer returned by `FPDFPage_GetAnnot`
+   * @param alignment     `PdfVerticalAlignment`
+   * @returns `true` on success
+   */
+  setAnnotationVerticalAlignment(annotationPtr, alignment) {
+    return !!this.pdfiumModule.EPDFAnnot_SetVerticalAlignment(annotationPtr, alignment);
+  }
+  /**
+   * Return the **default appearance** (font, size, colour) declared in the
+   * `/DA` string of a **FreeText** annotation.
+   *
+   * @param annotationPtr  pointer to `FPDF_ANNOTATION`
+   * @returns `{ font, fontSize, color }` or `undefined` when PDFium returns false
+   *
+   * NOTE – `font` is the raw `FPDF_STANDARD_FONT` enum value that PDFium uses
+   *        (same range as the C API: 0 = Courier, 12 = ZapfDingbats, …).
+   */
+  getAnnotationDefaultAppearance(annotationPtr) {
+    const fontPtr = this.malloc(4);
+    const sizePtr = this.malloc(4);
+    const rPtr = this.malloc(4);
+    const gPtr = this.malloc(4);
+    const bPtr = this.malloc(4);
+    const ok = !!this.pdfiumModule.EPDFAnnot_GetDefaultAppearance(
+      annotationPtr,
+      fontPtr,
+      sizePtr,
+      rPtr,
+      gPtr,
+      bPtr
+    );
+    if (!ok) {
+      [fontPtr, sizePtr, rPtr, gPtr, bPtr].forEach((p) => this.free(p));
+      return;
+    }
+    const pdf = this.pdfiumModule.pdfium;
+    const font = pdf.getValue(fontPtr, "i32");
+    const fontSize = pdf.getValue(sizePtr, "float");
+    const red = pdf.getValue(rPtr, "i32") & 255;
+    const green = pdf.getValue(gPtr, "i32") & 255;
+    const blue = pdf.getValue(bPtr, "i32") & 255;
+    [fontPtr, sizePtr, rPtr, gPtr, bPtr].forEach((p) => this.free(p));
+    return {
+      fontFamily: font,
+      fontSize,
+      fontColor: pdfColorToWebColor({ red, green, blue })
+    };
+  }
+  /**
+   * Write a **default appearance** (`/DA`) into a FreeText annotation.
+   *
+   * @param annotationPtr pointer to `FPDF_ANNOTATION`
+   * @param font          `FPDF_STANDARD_FONT` enum value
+   * @param fontSize      size in points (≥ 0)
+   * @param color         CSS-style `#rrggbb` string (alpha ignored)
+   * @returns `true` on success
+   */
+  setAnnotationDefaultAppearance(annotationPtr, font, fontSize, color) {
+    const { red, green, blue } = webColorToPdfColor(color);
+    return !!this.pdfiumModule.EPDFAnnot_SetDefaultAppearance(
+      annotationPtr,
+      font,
+      fontSize,
+      red & 255,
+      green & 255,
+      blue & 255
     );
   }
   /**
@@ -2902,6 +3289,117 @@ class PdfiumEngine {
     this.free(arrPtr);
     return { ok: okNative, pattern };
   }
+  /**
+   * Write the /BS /D dash pattern array for an annotation border.
+   *
+   * @param annotationPtr Pointer to FPDF_ANNOTATION
+   * @param pattern       Array of dash/space lengths in *points* (e.g. [3, 2])
+   *                      Empty array clears the pattern (solid line).
+   * @returns true on success
+   *
+   * @private
+   */
+  setBorderDashPattern(annotationPtr, pattern) {
+    if (!pattern || pattern.length === 0) {
+      return this.pdfiumModule.EPDFAnnot_SetBorderDashPattern(annotationPtr, 0, 0);
+    }
+    const clean = pattern.map((n) => Number.isFinite(n) && n > 0 ? n : 0).filter((n) => n > 0);
+    if (clean.length === 0) {
+      return this.pdfiumModule.EPDFAnnot_SetBorderDashPattern(annotationPtr, 0, 0);
+    }
+    const bytes = 4 * clean.length;
+    const bufPtr = this.malloc(bytes);
+    for (let i = 0; i < clean.length; i++) {
+      this.pdfiumModule.pdfium.setValue(bufPtr + 4 * i, clean[i], "float");
+    }
+    const ok = !!this.pdfiumModule.EPDFAnnot_SetBorderDashPattern(
+      annotationPtr,
+      bufPtr,
+      clean.length
+    );
+    this.free(bufPtr);
+    return ok;
+  }
+  /**
+   * Return the `/LE` array (start/end line-ending styles) for a LINE / POLYLINE annot.
+   *
+   * @param annotationPtr - pointer to an `FPDF_ANNOTATION`
+   * @returns `{ start, end }` or `undefined` when PDFium can't read them
+   *
+   * @private
+   */
+  getLineEndings(annotationPtr) {
+    const startPtr = this.malloc(4);
+    const endPtr = this.malloc(4);
+    const ok = !!this.pdfiumModule.EPDFAnnot_GetLineEndings(annotationPtr, startPtr, endPtr);
+    if (!ok) {
+      this.free(startPtr);
+      this.free(endPtr);
+      return void 0;
+    }
+    const start = this.pdfiumModule.pdfium.getValue(startPtr, "i32");
+    const end = this.pdfiumModule.pdfium.getValue(endPtr, "i32");
+    this.free(startPtr);
+    this.free(endPtr);
+    return { start, end };
+  }
+  /**
+   * Write the `/LE` array (start/end line-ending styles) for a LINE / POLYLINE annot.
+   * @param annotationPtr - pointer to an `FPDF_ANNOTATION`
+   * @param start - start line ending style
+   * @param end - end line ending style
+   * @returns `true` on success
+   */
+  setLineEndings(annotationPtr, start, end) {
+    return !!this.pdfiumModule.EPDFAnnot_SetLineEndings(annotationPtr, start, end);
+  }
+  /**
+   * Get the start and end points of a LINE / POLYLINE annot.
+   * @param annotationPtr - pointer to an `FPDF_ANNOTATION`
+   * @param page - logical page info object (`PdfPageObject`)
+   * @returns `{ start, end }` or `undefined` when PDFium can't read them
+   */
+  getLinePoints(annotationPtr, page) {
+    const startPointPtr = this.malloc(8);
+    const endPointPtr = this.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.free(startPointPtr);
+    this.free(endPointPtr);
+    return { start, end };
+  }
+  /**
+   * Set the two end‑points of a **Line** annotation
+   * by writing a new /L array `[ x1 y1 x2 y2 ]`.
+   * @param page - logical page info object (`PdfPageObject`)
+   * @param annotPtr - pointer to the annotation whose line points are needed
+   * @param start - start point
+   * @param end - end point
+   * @returns true on success
+   */
+  setLinePoints(page, annotPtr, start, end) {
+    const buf = this.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");
+    const ok = this.pdfiumModule.EPDFAnnot_SetLine(annotPtr, buf, buf + 8);
+    this.free(buf);
+    return ok;
+  }
   /**
    * Read `/QuadPoints` from any annotation and convert each quadrilateral to
    * device-space coordinates.
@@ -3066,14 +3564,16 @@ class PdfiumEngine {
     const contents = this.getAnnotString(annotationPtr, "Contents") || "";
     const state = this.getAnnotString(annotationPtr, "State");
     const stateModel = this.getAnnotString(annotationPtr, "StateModel");
-    const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
+    const color = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     const inReplyToId = this.getInReplyToId(pagePtr, annotationPtr);
     return {
       pageIndex: page.index,
       id: index,
       type: PdfAnnotationSubtype.TEXT,
       contents,
-      ...webAlphaColor,
+      color: color ?? "#FFFF00",
+      opacity,
       rect,
       inReplyToId,
       author,
@@ -3098,12 +3598,26 @@ class PdfiumEngine {
     const contents = this.getAnnotString(annotationPtr, "Contents") || "";
     const author = this.getAnnotString(annotationPtr, "T");
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
+    const defaultStyle = this.getAnnotString(annotationPtr, "DS");
+    const da = this.getAnnotationDefaultAppearance(annotationPtr);
+    const backgroundColor = this.getAnnotationColor(annotationPtr);
+    const textAlign = this.getAnnotationTextAlignment(annotationPtr);
+    const verticalAlign = this.getAnnotationVerticalAlignment(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     const modified = pdfDateToDate(modifiedRaw);
     const richContent = this.getAnnotRichContent(annotationPtr);
     return {
       pageIndex: page.index,
       id: index,
       type: PdfAnnotationSubtype.FREETEXT,
+      fontFamily: (da == null ? void 0 : da.fontFamily) ?? PdfStandardFont.Unknown,
+      fontSize: (da == null ? void 0 : da.fontSize) ?? 12,
+      fontColor: (da == null ? void 0 : da.fontColor) ?? "#000000",
+      verticalAlign,
+      backgroundColor,
+      opacity,
+      textAlign,
+      defaultStyle,
       richContent,
       contents,
       author,
@@ -3245,7 +3759,8 @@ class PdfiumEngine {
     const author = this.getAnnotString(annotationPtr, "T");
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
     const modified = pdfDateToDate(modifiedRaw);
-    const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
+    const color = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     const { width: strokeWidth } = this.getBorderStyle(annotationPtr);
     const inkList = this.getInkList(page, annotationPtr);
     const blendMode = this.pdfiumModule.EPDFAnnot_GetBlendMode(annotationPtr);
@@ -3256,8 +3771,9 @@ class PdfiumEngine {
       type: PdfAnnotationSubtype.INK,
       ...intent && { intent },
       blendMode,
-      ...webAlphaColor,
-      strokeWidth,
+      color: color ?? "#FF0000",
+      opacity,
+      strokeWidth: strokeWidth === 0 ? 1 : strokeWidth,
       rect,
       inkList,
       author,
@@ -3281,10 +3797,39 @@ class PdfiumEngine {
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
     const modified = pdfDateToDate(modifiedRaw);
     const vertices = this.readPdfAnnoVertices(page, pagePtr, annotationPtr);
+    const contents = this.getAnnotString(annotationPtr, "Contents") || "";
+    const strokeColor = this.getAnnotationColor(annotationPtr);
+    const interiorColor = this.getAnnotationColor(
+      annotationPtr,
+      PdfAnnotationColorType.InteriorColor
+    );
+    const opacity = this.getAnnotationOpacity(annotationPtr);
+    let { style: strokeStyle, width: strokeWidth } = this.getBorderStyle(annotationPtr);
+    let strokeDashArray;
+    if (strokeStyle === PdfAnnotationBorderStyle.DASHED) {
+      const { ok, pattern } = this.getBorderDashPattern(annotationPtr);
+      if (ok) {
+        strokeDashArray = pattern;
+      }
+    }
+    if (vertices.length > 1) {
+      const first = vertices[0];
+      const last = vertices[vertices.length - 1];
+      if (first.x === last.x && first.y === last.y) {
+        vertices.pop();
+      }
+    }
     return {
       pageIndex: page.index,
       id: index,
       type: PdfAnnotationSubtype.POLYGON,
+      contents,
+      strokeColor: strokeColor ?? "#FF0000",
+      color: interiorColor ?? "transparent",
+      opacity,
+      strokeWidth: strokeWidth === 0 ? 1 : strokeWidth,
+      strokeStyle,
+      strokeDashArray,
       rect,
       vertices,
       author,
@@ -3308,10 +3853,34 @@ class PdfiumEngine {
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
     const modified = pdfDateToDate(modifiedRaw);
     const vertices = this.readPdfAnnoVertices(page, pagePtr, annotationPtr);
+    const contents = this.getAnnotString(annotationPtr, "Contents") || "";
+    const strokeColor = this.getAnnotationColor(annotationPtr);
+    const interiorColor = this.getAnnotationColor(
+      annotationPtr,
+      PdfAnnotationColorType.InteriorColor
+    );
+    const opacity = this.getAnnotationOpacity(annotationPtr);
+    let { style: strokeStyle, width: strokeWidth } = this.getBorderStyle(annotationPtr);
+    let strokeDashArray;
+    if (strokeStyle === PdfAnnotationBorderStyle.DASHED) {
+      const { ok, pattern } = this.getBorderDashPattern(annotationPtr);
+      if (ok) {
+        strokeDashArray = pattern;
+      }
+    }
+    const lineEndings = this.getLineEndings(annotationPtr);
     return {
       pageIndex: page.index,
       id: index,
       type: PdfAnnotationSubtype.POLYLINE,
+      contents,
+      strokeColor: strokeColor ?? "#FF0000",
+      color: interiorColor ?? "transparent",
+      opacity,
+      strokeWidth: strokeWidth === 0 ? 1 : strokeWidth,
+      strokeStyle,
+      strokeDashArray,
+      lineEndings,
       rect,
       vertices,
       author,
@@ -3334,30 +3903,40 @@ class PdfiumEngine {
     const author = this.getAnnotString(annotationPtr, "T");
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
     const modified = pdfDateToDate(modifiedRaw);
-    const startPointPtr = this.malloc(8);
-    const endPointPtr = this.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 startPoint = 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 endPoint = this.convertPagePointToDevicePoint(page, {
-      x: endPointX,
-      y: endPointY
-    });
-    this.free(startPointPtr);
-    this.free(endPointPtr);
+    const linePoints = this.getLinePoints(annotationPtr, page);
+    const lineEndings = this.getLineEndings(annotationPtr);
+    const contents = this.getAnnotString(annotationPtr, "Contents") || "";
+    const strokeColor = this.getAnnotationColor(annotationPtr);
+    const interiorColor = this.getAnnotationColor(
+      annotationPtr,
+      PdfAnnotationColorType.InteriorColor
+    );
+    const opacity = this.getAnnotationOpacity(annotationPtr);
+    let { style: strokeStyle, width: strokeWidth } = this.getBorderStyle(annotationPtr);
+    let strokeDashArray;
+    if (strokeStyle === PdfAnnotationBorderStyle.DASHED) {
+      const { ok, pattern } = this.getBorderDashPattern(annotationPtr);
+      if (ok) {
+        strokeDashArray = pattern;
+      }
+    }
     return {
       pageIndex: page.index,
       id: index,
       type: PdfAnnotationSubtype.LINE,
       rect,
-      startPoint,
-      endPoint,
+      contents,
+      strokeWidth: strokeWidth === 0 ? 1 : strokeWidth,
+      strokeStyle,
+      strokeDashArray,
+      strokeColor: strokeColor ?? "#FF0000",
+      color: interiorColor ?? "transparent",
+      opacity,
+      linePoints: linePoints || { start: { x: 0, y: 0 }, end: { x: 0, y: 0 } },
+      lineEndings: lineEndings || {
+        start: PdfAnnotationLineEnding.None,
+        end: PdfAnnotationLineEnding.None
+      },
       author,
       modified
     };
@@ -3376,7 +3955,8 @@ class PdfiumEngine {
     const pageRect = this.readPageAnnoRect(annotationPtr);
     const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
     const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
-    const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
+    const color = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     const blendMode = this.pdfiumModule.EPDFAnnot_GetBlendMode(annotationPtr);
     const author = this.getAnnotString(annotationPtr, "T");
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
@@ -3390,7 +3970,8 @@ class PdfiumEngine {
       rect,
       contents,
       segmentRects,
-      ...webAlphaColor,
+      color: color ?? "#FFFF00",
+      opacity,
       author,
       modified
     };
@@ -3413,7 +3994,8 @@ class PdfiumEngine {
     const modified = pdfDateToDate(modifiedRaw);
     const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
     const contents = this.getAnnotString(annotationPtr, "Contents") || "";
-    const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
+    const color = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     const blendMode = this.pdfiumModule.EPDFAnnot_GetBlendMode(annotationPtr);
     return {
       pageIndex: page.index,
@@ -3423,7 +4005,8 @@ class PdfiumEngine {
       rect,
       contents,
       segmentRects,
-      ...webAlphaColor,
+      color: color ?? "#FF0000",
+      opacity,
       author,
       modified
     };
@@ -3446,7 +4029,8 @@ class PdfiumEngine {
     const modified = pdfDateToDate(modifiedRaw);
     const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
     const contents = this.getAnnotString(annotationPtr, "Contents") || "";
-    const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
+    const color = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     const blendMode = this.pdfiumModule.EPDFAnnot_GetBlendMode(annotationPtr);
     return {
       pageIndex: page.index,
@@ -3456,7 +4040,8 @@ class PdfiumEngine {
       rect,
       contents,
       segmentRects,
-      ...webAlphaColor,
+      color: color ?? "#FF0000",
+      opacity,
       author,
       modified
     };
@@ -3479,7 +4064,8 @@ class PdfiumEngine {
     const modified = pdfDateToDate(modifiedRaw);
     const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
     const contents = this.getAnnotString(annotationPtr, "Contents") || "";
-    const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
+    const color = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     const blendMode = this.pdfiumModule.EPDFAnnot_GetBlendMode(annotationPtr);
     return {
       pageIndex: page.index,
@@ -3489,7 +4075,8 @@ class PdfiumEngine {
       rect,
       contents,
       segmentRects,
-      ...webAlphaColor,
+      color: color ?? "#FF0000",
+      opacity,
       author,
       modified
     };
@@ -3751,6 +4338,10 @@ class PdfiumEngine {
     const rawFlags = this.pdfiumModule.FPDFAnnot_GetFlags(annotationPtr);
     return flagsToNames(rawFlags);
   }
+  setAnnotationFlags(annotationPtr, flags) {
+    const rawFlags = namesToFlags(flags);
+    return this.pdfiumModule.FPDFAnnot_SetFlags(annotationPtr, rawFlags);
+  }
   /**
    * Read circle annotation
    * @param page  - pdf page infor
@@ -3768,29 +4359,13 @@ class PdfiumEngine {
     const author = this.getAnnotString(annotationPtr, "T");
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
     const modified = pdfDateToDate(modifiedRaw);
-    const { color, opacity } = this.resolveAnnotationColor(
+    const interiorColor = this.getAnnotationColor(
       annotationPtr,
       PdfAnnotationColorType.InteriorColor
     );
-    const { color: strokeColor } = this.resolveAnnotationColor(annotationPtr);
+    const strokeColor = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     let { style: strokeStyle, width: strokeWidth } = this.getBorderStyle(annotationPtr);
-    let cloudyBorderIntensity;
-    let cloudyBorderInset;
-    if (strokeStyle === PdfAnnotationBorderStyle.CLOUDY || strokeStyle === PdfAnnotationBorderStyle.UNKNOWN) {
-      const { ok: hasEffect, intensity } = this.getBorderEffect(annotationPtr);
-      if (hasEffect) {
-        cloudyBorderIntensity = intensity;
-        strokeStyle = PdfAnnotationBorderStyle.CLOUDY;
-        const {
-          ok: hasInset,
-          left,
-          top,
-          right,
-          bottom
-        } = this.getRectangleDifferences(annotationPtr);
-        if (hasInset) cloudyBorderInset = [left, top, right, bottom];
-      }
-    }
     let strokeDashArray;
     if (strokeStyle === PdfAnnotationBorderStyle.DASHED) {
       const { ok, pattern } = this.getBorderDashPattern(annotationPtr);
@@ -3803,16 +4378,14 @@ class PdfiumEngine {
       id: index,
       type: PdfAnnotationSubtype.CIRCLE,
       flags,
-      color,
+      color: interiorColor ?? "transparent",
       opacity,
       strokeWidth,
-      strokeColor,
+      strokeColor: strokeColor ?? "#FF0000",
       strokeStyle,
       rect,
       author,
       modified,
-      ...cloudyBorderIntensity !== void 0 && { cloudyBorderIntensity },
-      ...cloudyBorderInset !== void 0 && { cloudyBorderInset },
       ...strokeDashArray !== void 0 && { strokeDashArray }
     };
   }
@@ -3833,29 +4406,13 @@ class PdfiumEngine {
     const author = this.getAnnotString(annotationPtr, "T");
     const modifiedRaw = this.getAnnotString(annotationPtr, "M");
     const modified = pdfDateToDate(modifiedRaw);
-    const { color, opacity } = this.resolveAnnotationColor(
+    const interiorColor = this.getAnnotationColor(
       annotationPtr,
       PdfAnnotationColorType.InteriorColor
     );
-    const { color: strokeColor } = this.resolveAnnotationColor(annotationPtr);
+    const strokeColor = this.getAnnotationColor(annotationPtr);
+    const opacity = this.getAnnotationOpacity(annotationPtr);
     let { style: strokeStyle, width: strokeWidth } = this.getBorderStyle(annotationPtr);
-    let cloudyBorderIntensity;
-    let cloudyBorderInset;
-    if (strokeStyle === PdfAnnotationBorderStyle.CLOUDY || strokeStyle === PdfAnnotationBorderStyle.UNKNOWN) {
-      const { ok: hasEffect, intensity } = this.getBorderEffect(annotationPtr);
-      if (hasEffect) {
-        cloudyBorderIntensity = intensity;
-        strokeStyle = PdfAnnotationBorderStyle.CLOUDY;
-        const {
-          ok: hasInset,
-          left,
-          top,
-          right,
-          bottom
-        } = this.getRectangleDifferences(annotationPtr);
-        if (hasInset) cloudyBorderInset = [left, top, right, bottom];
-      }
-    }
     let strokeDashArray;
     if (strokeStyle === PdfAnnotationBorderStyle.DASHED) {
       const { ok, pattern } = this.getBorderDashPattern(annotationPtr);
@@ -3868,16 +4425,14 @@ class PdfiumEngine {
       id: index,
       type: PdfAnnotationSubtype.SQUARE,
       flags,
-      color,
+      color: interiorColor ?? "transparent",
       opacity,
-      strokeColor,
+      strokeColor: strokeColor ?? "#FF0000",
       strokeWidth,
       strokeStyle,
       rect,
       author,
       modified,
-      ...cloudyBorderIntensity !== void 0 && { cloudyBorderIntensity },
-      ...cloudyBorderInset !== void 0 && { cloudyBorderInset },
       ...strokeDashArray !== void 0 && { strokeDashArray }
     };
   }
@@ -3956,6 +4511,19 @@ class PdfiumEngine {
     this.free(ptr);
     return value && value !== "undefined" ? value : void 0;
   }
+  /**
+   * Write the `/IT` (Intent) name into an annotation dictionary.
+   *
+   * Mirrors EPDFAnnot_SetIntent in PDFium (expects a UTF‑8 FPDF_BYTESTRING).
+   *
+   * @param annotationPtr Pointer returned by FPDFPage_GetAnnot
+   * @param intent        Name without leading slash, e.g. `"PolygonCloud"`
+   *                      A leading “/” will be stripped for convenience.
+   * @returns             true on success, false otherwise
+   */
+  setAnnotIntent(annotationPtr, intent) {
+    return this.pdfiumModule.EPDFAnnot_SetIntent(annotationPtr, intent);
+  }
   /**
    * Returns the rich‑content string stored in the annotation’s `/RC` entry.
    *
@@ -4013,14 +4581,37 @@ class PdfiumEngine {
         x: pointX,
         y: pointY
       });
-      vertices.push({
-        x,
-        y
-      });
+      const last = vertices[vertices.length - 1];
+      if (!last || last.x !== x || last.y !== y) {
+        vertices.push({ x, y });
+      }
     }
     this.free(pointsPtr);
     return vertices;
   }
+  /**
+   * Sync the vertices of a polygon or polyline annotation.
+   *
+   * @param page  - pdf page infor
+   * @param annotPtr - pointer to pdf annotation
+   * @param vertices - the vertices to be set
+   * @returns true on success
+   *
+   * @private
+   */
+  setPdfAnnoVertices(page, annotPtr, vertices) {
+    const pdf = this.pdfiumModule.pdfium;
+    const FS_POINTF_SIZE = 8;
+    const buf = this.malloc(FS_POINTF_SIZE * vertices.length);
+    vertices.forEach((v, i) => {
+      const pagePt = this.convertDevicePointToPagePoint(page, v);
+      pdf.setValue(buf + i * FS_POINTF_SIZE + 0, pagePt.x, "float");
+      pdf.setValue(buf + i * FS_POINTF_SIZE + 4, pagePt.y, "float");
+    });
+    const ok = this.pdfiumModule.EPDFAnnot_SetVertices(annotPtr, buf, vertices.length);
+    this.free(buf);
+    return ok;
+  }
   /**
    * Read the target of pdf bookmark
    * @param docPtr - pointer to pdf document object
@@ -4671,70 +5262,6 @@ class PdfiumEngine {
     this.free(bufferPtr);
     return ap;
   }
-  /**
-   * Change the visible colour (and opacity) of an existing annotation.
-   *
-   * For markup annotations (highlight / underline / strikeout / squiggly) we
-   * first clear the AP dictionary entry, otherwise the stored appearance stream
-   * will override the new tint.  For all other sub-types we keep the existing
-   * AP so custom artwork isn't lost.
-   *
-   * @param doc         logical document object
-   * @param page        logical page object
-   * @param annotation  the annotation we want to recolour
-   * @param colour      RGBA tuple (0-255 per channel)
-   * @param which       0 = stroke/fill colour  (PDFium's "colourType" param)
-   *
-   * @returns `true` when the operation succeeded
-   */
-  updateAnnotationColor(doc, page, annotation, color, which = 0) {
-    this.logger.debug(
-      LOG_SOURCE,
-      LOG_CATEGORY,
-      "setAnnotationColor",
-      doc,
-      page,
-      annotation,
-      color,
-      which
-    );
-    this.logger.perf(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor", "Begin", doc.id);
-    const task = PdfTaskHelper.create();
-    try {
-      const ctx = this.cache.getContext(doc.id);
-      if (!ctx) {
-        this.logger.perf(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor", "End", doc.id);
-        this.logger.warn(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor: doc closed");
-        task.resolve(false);
-        return task;
-      }
-      const pageCtx = ctx.acquirePage(page.index);
-      const annotPtr = this.pdfiumModule.FPDFPage_GetAnnot(pageCtx.pagePtr, annotation.id);
-      if (!annotPtr) {
-        this.logger.perf(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor", "End", doc.id);
-        this.logger.warn(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor: annot not found");
-        pageCtx.release();
-        task.resolve(false);
-        return task;
-      }
-      const ok = this.setAnnotationColor(annotPtr, color, which);
-      if (ok) {
-        this.pdfiumModule.FPDFPage_GenerateContent(pageCtx.pagePtr);
-      }
-      this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
-      pageCtx.release();
-      this.logger.perf(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor", "End", doc.id);
-      task.resolve(!!ok);
-    } catch (error) {
-      this.logger.perf(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor", "End", doc.id);
-      this.logger.error(LOG_SOURCE, LOG_CATEGORY, "setAnnotationColor: error", error);
-      task.reject({
-        code: PdfErrorCode.Unknown,
-        message: `Failed to set annotation color: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-    return task;
-  }
   /**
    * Set the rect of specified annotation
    * @param page - page info that the annotation is belonged to
@@ -5040,4 +5567,4 @@ export {
   readArrayBuffer as c,
   readString as r
 };
-//# sourceMappingURL=engine-M0_XZhss.js.map
+//# sourceMappingURL=engine-O49988D4.js.map