@embedpdf/engines 1.0.6 → 1.0.8

package/dist/pdfium.cjs

@@ -912,11 +912,17 @@ class PdfiumEngine {
         let isSucceed = false;
         switch (annotation.type) {
             case models.PdfAnnotationSubtype.INK:
-                isSucceed = this.addInkStroke(page, pageCtx.pagePtr, annotationPtr, annotation.inkList);
+                isSucceed = this.addInkStroke(page, pageCtx.pagePtr, annotationPtr, annotation);
                 break;
             case models.PdfAnnotationSubtype.STAMP:
                 isSucceed = this.addStampContent(ctx.docPtr, page, pageCtx.pagePtr, annotationPtr, annotation.rect, annotation.contents);
                 break;
+            case models.PdfAnnotationSubtype.UNDERLINE:
+            case models.PdfAnnotationSubtype.STRIKEOUT:
+            case models.PdfAnnotationSubtype.SQUIGGLY:
+            case models.PdfAnnotationSubtype.HIGHLIGHT:
+                isSucceed = this.addTextMarkupContent(page, pageCtx.pagePtr, annotationPtr, annotation);
+                break;
         }
         if (!isSucceed) {
             this.pdfiumModule.FPDFPage_RemoveAnnot(pageCtx.pagePtr, annotationPtr);
@@ -927,90 +933,104 @@ class PdfiumEngine {
                 message: 'can not add content of the annotation',
             });
         }
+        this.pdfiumModule.EPDFAnnot_GenerateAppearance(annotationPtr);
         this.pdfiumModule.FPDFPage_GenerateContent(pageCtx.pagePtr);
+        const annotId = this.pdfiumModule.FPDFPage_GetAnnotIndex(pageCtx.pagePtr, annotationPtr);
         this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
         pageCtx.release();
         this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `CreatePageAnnotation`, 'End', `${doc.id}-${page.index}`);
-        return models.PdfTaskHelper.resolve(true);
+        return annotId >= 0
+            ? models.PdfTaskHelper.resolve(annotId)
+            : models.PdfTaskHelper.reject({
+                code: models.PdfErrorCode.CantCreateAnnot,
+                message: 'annotation created but index could not be determined',
+            });
     }
     /**
-     * {@inheritDoc @embedpdf/models!PdfEngine.transformPageAnnotation}
+     * Update an existing page annotation in-place
      *
-     * @public
+     *  • Locates the annot by page-local index (`annotation.id`)
+     *  • Re-writes its /Rect and type-specific payload
+     *  • Calls FPDFPage_GenerateContent so the new appearance is rendered
+     *
+     * @returns PdfTask<boolean>  –  true on success
      */
-    transformPageAnnotation(doc, page, annotation, transformation) {
-        this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, 'transformPageAnnotation', doc, page, annotation, transformation);
-        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `TransformPageAnnotation`, 'Begin', `${doc.id}-${page.index}`);
+    updatePageAnnotation(doc, page, annotation) {
+        this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, 'updatePageAnnotation', doc, page, annotation);
+        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'UpdatePageAnnotation', 'Begin', `${doc.id}-${page.index}`);
         const ctx = this.cache.getContext(doc.id);
         if (!ctx) {
-            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `TransformPageAnnotation`, 'End', `${doc.id}-${page.index}`);
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'UpdatePageAnnotation', 'End', `${doc.id}-${page.index}`);
             return models.PdfTaskHelper.reject({
                 code: models.PdfErrorCode.DocNotOpen,
                 message: 'document does not open',
             });
         }
         const pageCtx = ctx.acquirePage(page.index);
-        const annotationPtr = this.pdfiumModule.FPDFPage_GetAnnot(pageCtx.pagePtr, annotation.id);
-        const rect = {
-            origin: {
-                x: annotation.rect.origin.x + transformation.offset.x,
-                y: annotation.rect.origin.y + transformation.offset.y,
-            },
-            size: {
-                width: annotation.rect.size.width * transformation.scale.width,
-                height: annotation.rect.size.height * transformation.scale.height,
-            },
-        };
-        if (!this.setPageAnnoRect(page, pageCtx.pagePtr, annotationPtr, rect)) {
-            this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
+        const annotPtr = this.pdfiumModule.FPDFPage_GetAnnot(pageCtx.pagePtr, annotation.id);
+        if (!annotPtr) {
+            pageCtx.release();
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'UpdatePageAnnotation', 'End', `${doc.id}-${page.index}`);
+            return models.PdfTaskHelper.reject({ code: models.PdfErrorCode.NotFound, message: 'annotation not found' });
+        }
+        /* 1 ── (re)set bounding-box ────────────────────────────────────────────── */
+        if (!this.setPageAnnoRect(page, pageCtx.pagePtr, annotPtr, annotation.rect)) {
+            this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
             pageCtx.release();
-            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `TransformPageAnnotation`, 'End', `${doc.id}-${page.index}`);
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'UpdatePageAnnotation', 'End', `${doc.id}-${page.index}`);
             return models.PdfTaskHelper.reject({
                 code: models.PdfErrorCode.CantSetAnnotRect,
-                message: 'can not set the rect of the annotation',
+                message: 'failed to move annotation',
             });
         }
+        /* 2 ── wipe previous payload and rebuild fresh one ─────────────────────── */
+        let ok = false;
         switch (annotation.type) {
-            case models.PdfAnnotationSubtype.INK:
-                {
-                    if (!this.pdfiumModule.FPDFAnnot_RemoveInkList(annotationPtr)) {
-                        this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
-                        pageCtx.release();
-                        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `TransformPageAnnotation`, 'End', `${doc.id}-${page.index}`);
-                        return models.PdfTaskHelper.reject({
-                            code: models.PdfErrorCode.CantRemoveInkList,
-                            message: 'can not set the rect of the annotation',
-                        });
-                    }
-                    const inkList = annotation.inkList.map((inkStroke) => {
-                        return {
-                            points: inkStroke.points.map((point) => {
-                                return {
-                                    x: rect.origin.x +
-                                        (point.x - annotation.rect.origin.x) * transformation.scale.width,
-                                    y: rect.origin.y +
-                                        (point.y - annotation.rect.origin.y) * transformation.scale.height,
-                                };
-                            }),
-                        };
-                    });
-                    if (!this.addInkStroke(page, pageCtx.pagePtr, annotationPtr, inkList)) {
-                        this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
-                        pageCtx.release();
-                        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `TransformPageAnnotation`, 'End', `${doc.id}-${page.index}`);
-                        return models.PdfTaskHelper.reject({
-                            code: models.PdfErrorCode.CantAddInkStoke,
-                            message: 'can not add stroke to the ink list of annotation',
-                        });
-                    }
+            /* ── Ink ─────────────────────────────────────────────────────────────── */
+            case models.PdfAnnotationSubtype.INK: {
+                /* clear every existing stroke first */
+                if (!this.pdfiumModule.FPDFAnnot_RemoveInkList(annotPtr))
+                    break;
+                ok = this.addInkStroke(page, pageCtx.pagePtr, annotPtr, annotation);
+                break;
+            }
+            /* ── Stamp ───────────────────────────────────────────────────────────── */
+            case models.PdfAnnotationSubtype.STAMP: {
+                /* drop every page-object inside the annot */
+                for (let i = this.pdfiumModule.FPDFAnnot_GetObjectCount(annotPtr) - 1; i >= 0; i--) {
+                    this.pdfiumModule.FPDFAnnot_RemoveObject(annotPtr, i);
                 }
+                ok = this.addStampContent(ctx.docPtr, page, pageCtx.pagePtr, annotPtr, annotation.rect, annotation.contents);
+                break;
+            }
+            /* ── Text-markup family ──────────────────────────────────────────────── */
+            case models.PdfAnnotationSubtype.HIGHLIGHT:
+            case models.PdfAnnotationSubtype.UNDERLINE:
+            case models.PdfAnnotationSubtype.STRIKEOUT:
+            case models.PdfAnnotationSubtype.SQUIGGLY: {
+                /* replace quad-points / colour / strings in one go */
+                ok = this.addTextMarkupContent(page, pageCtx.pagePtr, annotPtr, annotation);
                 break;
+            }
+            /* ── Unsupported edits – fall through to error ───────────────────────── */
+            default:
+                ok = false;
         }
-        this.pdfiumModule.FPDFPage_GenerateContent(pageCtx.pagePtr);
-        this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
+        /* 3 ── regenerate appearance if payload was changed ───────────────────── */
+        if (ok) {
+            this.pdfiumModule.EPDFAnnot_GenerateAppearance(annotPtr);
+            this.pdfiumModule.FPDFPage_GenerateContent(pageCtx.pagePtr);
+        }
+        /* 4 ── tidy-up native handles ──────────────────────────────────────────── */
+        this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
         pageCtx.release();
-        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `TransformPageAnnotation`, 'End', `${doc.id}-${page.index}`);
-        return models.PdfTaskHelper.resolve(true);
+        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'UpdatePageAnnotation', 'End', `${doc.id}-${page.index}`);
+        return ok
+            ? models.PdfTaskHelper.resolve(true)
+            : models.PdfTaskHelper.reject({
+                code: models.PdfErrorCode.CantSetAnnotContent,
+                message: 'failed to update annotation',
+            });
     }
     /**
      * {@inheritDoc @embedpdf/models!PdfEngine.removePageAnnotation}
@@ -1632,21 +1652,60 @@ class PdfiumEngine {
      *
      * @private
      */
-    addInkStroke(page, pagePtr, annotationPtr, inkList) {
-        for (const inkStroke of inkList) {
-            const inkPointsCount = inkStroke.points.length;
-            const inkPointsPtr = this.malloc(inkPointsCount * 8);
-            for (let i = 0; i < inkPointsCount; i++) {
-                const point = inkStroke.points[i];
-                const { x, y } = this.convertDevicePointToPagePoint(page, point);
-                this.pdfiumModule.pdfium.setValue(inkPointsPtr + i * 8, x, 'float');
-                this.pdfiumModule.pdfium.setValue(inkPointsPtr + i * 8 + 4, y, 'float');
-            }
-            if (this.pdfiumModule.FPDFAnnot_AddInkStroke(annotationPtr, inkPointsPtr, inkPointsCount) === -1) {
-                this.free(inkPointsPtr);
-                return false;
-            }
-            this.free(inkPointsPtr);
+    addInkStroke(page, pagePtr, annotationPtr, annotation) {
+        if (!this.setBorderStyle(annotationPtr, models.PdfAnnotationBorderStyle.SOLID, annotation.strokeWidth)) {
+            return false;
+        }
+        if (!this.setPageAnnoRect(page, pagePtr, annotationPtr, annotation.rect)) {
+            return false;
+        }
+        if (!this.setInkList(page, annotationPtr, annotation.inkList)) {
+            return false;
+        }
+        if (!this.setAnnotString(annotationPtr, 'T', annotation.author || '')) {
+            return false;
+        }
+        if (!this.setAnnotString(annotationPtr, 'M', models.dateToPdfDate(annotation.modified))) {
+            return false;
+        }
+        if (!this.setAnnotationColor(annotationPtr, {
+            color: annotation.color ?? '#FFFF00',
+            opacity: annotation.opacity ?? 1,
+        }, models.PdfAnnotationColorType.Color)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Add highlight content to annotation
+     * @param page - page info
+     * @param annotationPtr - pointer to highlight annotation
+     * @param annotation - highlight annotation
+     * @returns whether highlight content is added to annotation
+     *
+     * @private
+     */
+    addTextMarkupContent(page, pagePtr, annotationPtr, annotation) {
+        if (!this.setPageAnnoRect(page, pagePtr, annotationPtr, annotation.rect)) {
+            return false;
+        }
+        if (!this.syncQuadPointsAnno(page, annotationPtr, annotation.segmentRects)) {
+            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', models.dateToPdfDate(annotation.modified))) {
+            return false;
+        }
+        if (!this.setAnnotationColor(annotationPtr, {
+            color: annotation.color ?? '#FFFF00',
+            opacity: annotation.opacity ?? 1,
+        }, models.PdfAnnotationColorType.Color)) {
+            return false;
         }
         return true;
     }
@@ -2272,8 +2331,6 @@ class PdfiumEngine {
                     annotation = this.readPdfCaretAnno(page, pageCtx.pagePtr, annotationPtr, index);
                 }
                 break;
-            case models.PdfAnnotationSubtype.POPUP:
-                break;
             default:
                 {
                     annotation = this.readPdfAnno(page, pageCtx.pagePtr, subType, annotationPtr, index);
@@ -2294,14 +2351,13 @@ class PdfiumEngine {
      *
      * @private
      */
-    readAnnotationColor(annotationPtr) {
+    readAnnotationColor(annotationPtr, colorType = models.PdfAnnotationColorType.Color) {
         const rPtr = this.malloc(4);
         const gPtr = this.malloc(4);
         const bPtr = this.malloc(4);
         const aPtr = this.malloc(4);
         // colourType 0 = "colour" (stroke/fill); other types are interior/border
-        const ok = this.pdfiumModule.FPDFAnnot_GetColor(annotationPtr, 
-        /* colorType = */ 0, rPtr, gPtr, bPtr, aPtr);
+        const ok = this.pdfiumModule.EPDFAnnot_GetColor(annotationPtr, colorType, rPtr, gPtr, bPtr, aPtr);
         let colour;
         if (ok) {
             colour = {
@@ -2319,116 +2375,144 @@ class PdfiumEngine {
     }
     /* --------------------------------------------------------------------------- */
     /**
-     * Extract the fill (or, if absent, the stroke) colour from a **path object**
-     * inside an appearance stream.
+     * Resolve the visible fill colour for **Highlight / Underline / StrikeOut /
+     * Squiggly** markup annotations.
      *
-     * Works for simple highlights produced by Chrome, Preview, etc. that paint a
-     * single filled rectangle with the desired tint.
+     * 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)
      *
-     * @param pathPtr - pointer to a `FPDF_PAGEOBJECT` of type **PATH**
-     * @returns RGBA tuple or `undefined` when no colour is set on the path
+     * @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)
      *
      * @private
      */
-    getColorFromPath(pathPtr) {
-        const r = this.malloc(4), g = this.malloc(4), b = this.malloc(4), a = this.malloc(4);
-        const fillOk = this.pdfiumModule.FPDFPageObj_GetFillColor(pathPtr, r, g, b, a);
-        const strokeOk = !fillOk && // try stroke only if fill failed
-            this.pdfiumModule.FPDFPageObj_GetStrokeColor(pathPtr, r, g, b, a);
-        const ok = fillOk || strokeOk;
-        let c;
-        if (ok) {
-            c = {
-                red: this.pdfiumModule.pdfium.getValue(r, 'i32') & 0xff,
-                green: this.pdfiumModule.pdfium.getValue(g, 'i32') & 0xff,
-                blue: this.pdfiumModule.pdfium.getValue(b, 'i32') & 0xff,
-                alpha: this.pdfiumModule.pdfium.getValue(a, 'i32') & 0xff,
-            };
-        }
-        this.free(r);
-        this.free(g);
-        this.free(b);
-        this.free(a);
-        return c;
+    resolveAnnotationColor(annotationPtr, colorType = models.PdfAnnotationColorType.Color, fallback = { red: 255, green: 245, blue: 155, alpha: 255 }) {
+        const pdfColor = this.readAnnotationColor(annotationPtr, colorType) ?? fallback;
+        return models.pdfAlphaColorToWebAlphaColor(pdfColor);
     }
-    /* --------------------------------------------------------------------------- */
     /**
-     * Recursively walk a page-object tree (PATHs and nested FORM XObjects) until
-     * a colour can be extracted.
-     *
-     * Acrobat often wraps its highlight rectangle in a Form XObject referenced by
-     * the "Do" operator, so this function drills down unlimited depth.
+     * Set the fill/stroke colour for a **Highlight / Underline / StrikeOut / Squiggly** markup annotation.
      *
-     * @param objPtr - pointer to a `FPDF_PAGEOBJECT`
-     * @returns First RGBA tint found, or `undefined` if none of the descendants
-     *          carry an explicit fill/stroke colour
+     * @param annotationPtr - pointer to the annotation whose colour is being set
+     * @param webAlphaColor - WebAlphaColor with hex color and opacity (0-1)
+     * @param shouldClearAP - whether to clear the /AP entry
+     * @param which - which colour to set (0 = fill, 1 = stroke)
+     * @returns `true` if the operation was successful
      *
      * @private
      */
-    walkPageObjTree(objPtr) {
-        const type = this.pdfiumModule.FPDFPageObj_GetType(objPtr);
-        if (type === models.PdfPageObjectType.PATH)
-            return this.getColorFromPath(objPtr);
-        if (type !== models.PdfPageObjectType.FORM)
-            return undefined;
-        const cnt = this.pdfiumModule.FPDFFormObj_CountObjects(objPtr);
-        for (let i = 0; i < cnt; i++) {
-            const child = this.pdfiumModule.FPDFFormObj_GetObject(objPtr, i);
-            if (!child)
-                continue;
-            const c = this.walkPageObjTree(child);
-            if (c)
-                return c;
-        }
-        return undefined;
+    setAnnotationColor(annotationPtr, webAlphaColor, colorType = models.PdfAnnotationColorType.Color) {
+        const pdfAlphaColor = models.webAlphaColorToPdfAlphaColor(webAlphaColor);
+        return this.pdfiumModule.EPDFAnnot_SetColor(annotationPtr, colorType, pdfAlphaColor.red & 0xff, pdfAlphaColor.green & 0xff, pdfAlphaColor.blue & 0xff, (pdfAlphaColor.alpha ?? 255) & 0xff);
     }
-    /* --------------------------------------------------------------------------- */
     /**
-     * Iterate over every top-level object in the annotation's **appearance stream**
-     * and invoke {@link walkPageObjTree} to locate a usable tint.
+     * Border‐style + width helper
      *
-     * Catches:
-     *   • Simple filled path (Preview, Chrome)
-     *   • Form XObject containing the path (Acrobat)
+     * Tries the new PDFium helper `EPDFAnnot_GetBorderStyle()` (patch series
+     * 9 July 2025).
      *
-     * @param annotPtr - pointer to an `FPDF_ANNOTATION`
-     * @returns RGBA tuple or `undefined` when no colour can be resolved from AP
+     * @param  annotationPtr  pointer to an `FPDF_ANNOTATION`
+     * @returns `{ ok, style, width }`
+     *          • `ok`     – `true` when the call succeeded
+     *          • `style`  – `PdfAnnotationBorderStyle` enum
+     *          • `width`  – stroke-width in points (defaults to 0 pt)
+     */
+    getBorderStyle(annotationPtr) {
+        /* 1 ── allocate tmp storage for the returned width ─────────────── */
+        const widthPtr = this.malloc(4);
+        let width = 0;
+        let style = models.PdfAnnotationBorderStyle.UNKNOWN;
+        let ok = false;
+        style = this.pdfiumModule.EPDFAnnot_GetBorderStyle(annotationPtr, widthPtr);
+        width = this.pdfiumModule.pdfium.getValue(widthPtr, 'float');
+        ok = style !== models.PdfAnnotationBorderStyle.UNKNOWN;
+        this.free(widthPtr);
+        return { ok, style, width };
+    }
+    setBorderStyle(annotationPtr, style, width) {
+        return this.pdfiumModule.EPDFAnnot_SetBorderStyle(annotationPtr, style, width);
+    }
+    /**
+     * Border-effect (“cloudy”) helper
      *
-     * @private
+     * Calls the new PDFium function `EPDFAnnot_GetBorderEffect()` (July 2025).
+     *
+     * @param  annotationPtr  pointer to an `FPDF_ANNOTATION`
+     * @returns `{ ok, intensity }`
+     *          • `ok`        – `true` when the annotation *does* have a
+     *                          valid cloudy-border effect
+     *          • `intensity` – radius/intensity value (0 when `ok` is false)
      */
-    colorFromAppearance(annotPtr) {
-        const n = this.pdfiumModule.FPDFAnnot_GetObjectCount(annotPtr);
-        for (let i = 0; i < n; i++) {
-            const obj = this.pdfiumModule.FPDFAnnot_GetObject(annotPtr, i);
-            if (!obj)
-                continue;
-            const c = this.walkPageObjTree(obj);
-            if (c)
-                return c;
-        }
-        return undefined;
+    getBorderEffect(annotationPtr) {
+        const intensityPtr = this.malloc(4);
+        const ok = !!this.pdfiumModule.EPDFAnnot_GetBorderEffect(annotationPtr, intensityPtr);
+        const intensity = ok ? this.pdfiumModule.pdfium.getValue(intensityPtr, 'float') : 0;
+        this.free(intensityPtr);
+        return { ok, intensity };
     }
-    /* --------------------------------------------------------------------------- */
     /**
-     * Resolve the visible fill colour for **Highlight / Underline / StrikeOut /
-     * Squiggly** markup annotations.
+     * Rectangle-differences helper ( /RD array on Square / Circle annots )
      *
-     * 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)
+     * Calls `EPDFAnnot_GetRectangleDifferences()` introduced in July 2025.
      *
-     * @param annotationPtr - pointer to an `FPDF_ANNOTATION`
-     * @param fallback      - colour to use when the PDF stores no tint at all
-     * @returns Guaranteed RGBA tuple (never `undefined`)
+     * @param  annotationPtr  pointer to an `FPDF_ANNOTATION`
+     * @returns `{ ok, left, top, right, bottom }`
+     *          • `ok`     – `true` when the annotation *has* an /RD entry
+     *          • the four floats are 0 when `ok` is false
+     */
+    getRectangleDifferences(annotationPtr) {
+        /* tmp storage ─────────────────────────────────────────── */
+        const lPtr = this.malloc(4);
+        const tPtr = this.malloc(4);
+        const rPtr = this.malloc(4);
+        const bPtr = this.malloc(4);
+        const ok = !!this.pdfiumModule.EPDFAnnot_GetRectangleDifferences(annotationPtr, lPtr, tPtr, rPtr, bPtr);
+        const pdf = this.pdfiumModule.pdfium;
+        const left = pdf.getValue(lPtr, 'float');
+        const top = pdf.getValue(tPtr, 'float');
+        const right = pdf.getValue(rPtr, 'float');
+        const bottom = pdf.getValue(bPtr, 'float');
+        /* cleanup ─────────────────────────────────────────────── */
+        this.free(lPtr);
+        this.free(tPtr);
+        this.free(rPtr);
+        this.free(bPtr);
+        return { ok, left, top, right, bottom };
+    }
+    /**
+     * Dash-pattern helper ( /BS → /D array, dashed borders only )
      *
-     * @private
+     * Uses the two new PDFium helpers:
+     *   • `EPDFAnnot_GetBorderDashPatternCount`
+     *   • `EPDFAnnot_GetBorderDashPattern`
+     *
+     * @param  annotationPtr  pointer to an `FPDF_ANNOTATION`
+     * @returns `{ ok, pattern }`
+     *          • `ok`       – `true` when the annot is dashed *and* the array
+     *                          was retrieved successfully
+     *          • `pattern`  – numeric array of dash/space lengths (empty when `ok` is false)
      */
-    resolveAnnotationColor(annotationPtr, fallback = { red: 255, green: 245, blue: 155, alpha: 255 }) {
-        return (this.readAnnotationColor(annotationPtr) ?? // 1 – /C entry
-            this.colorFromAppearance(annotationPtr) ?? // 2 – AP stream walk
-            fallback // 3 – default
-        );
+    getBorderDashPattern(annotationPtr) {
+        const count = this.pdfiumModule.EPDFAnnot_GetBorderDashPatternCount(annotationPtr);
+        if (count === 0) {
+            return { ok: false, pattern: [] };
+        }
+        /* allocate `count` floats on the WASM heap */
+        const arrPtr = this.malloc(4 * count);
+        const okNative = !!this.pdfiumModule.EPDFAnnot_GetBorderDashPattern(annotationPtr, arrPtr, count);
+        /* copy out */
+        const pattern = [];
+        if (okNative) {
+            const pdf = this.pdfiumModule.pdfium;
+            for (let i = 0; i < count; i++) {
+                pattern.push(pdf.getValue(arrPtr + 4 * i, 'float'));
+            }
+        }
+        this.free(arrPtr);
+        return { ok: okNative, pattern };
     }
     /**
      * Read `/QuadPoints` from any annotation and convert each quadrilateral to
@@ -2441,11 +2525,11 @@ class PdfiumEngine {
      *
      * @param page          - logical page info object (`PdfPageObject`)
      * @param annotationPtr - pointer to the annotation whose quads are needed
-     * @returns Array of `Quad` objects (`[]` if the annotation has no quads)
+     * @returns Array of `Rect` objects (`[]` if the annotation has no quads)
      *
      * @private
      */
-    readAnnotationQuads(page, annotationPtr) {
+    getQuadPointsAnno(page, annotationPtr) {
         const quadCount = this.pdfiumModule.FPDFAnnot_CountAttachmentPoints(annotationPtr);
         if (quadCount === 0)
             return [];
@@ -2472,7 +2556,116 @@ class PdfiumEngine {
             }
             this.free(quadPtr);
         }
-        return quads;
+        return quads.map(models.quadToRect);
+    }
+    /**
+     * Set the quadrilaterals for a **Highlight / Underline / StrikeOut / Squiggly** markup annotation.
+     *
+     * @param page          - logical page info object (`PdfPageObject`)
+     * @param annotationPtr - pointer to the annotation whose quads are needed
+     * @param rects         - array of `Rect` objects (`[]` if the annotation has no quads)
+     * @returns `true` if the operation was successful
+     *
+     * @private
+     */
+    syncQuadPointsAnno(page, annotPtr, rects) {
+        const FS_QUADPOINTSF_SIZE = 8 * 4; // eight floats, 32 bytes
+        const pdf = this.pdfiumModule.pdfium;
+        const count = this.pdfiumModule.FPDFAnnot_CountAttachmentPoints(annotPtr);
+        const buf = this.malloc(FS_QUADPOINTSF_SIZE);
+        /** write one quad into `buf` in annotation space */
+        const writeQuad = (r) => {
+            const q = models.rectToQuad(r); // TL, TR, BR, BL
+            const p1 = this.convertDevicePointToPagePoint(page, q.p1);
+            const p2 = this.convertDevicePointToPagePoint(page, q.p2);
+            const p3 = this.convertDevicePointToPagePoint(page, q.p3); // BR
+            const p4 = this.convertDevicePointToPagePoint(page, q.p4); // BL
+            // PDF QuadPoints order: BL, BR, TL, TR (bottom-left, bottom-right, top-left, top-right)
+            pdf.setValue(buf + 0, p1.x, 'float'); // BL (bottom-left)
+            pdf.setValue(buf + 4, p1.y, 'float');
+            pdf.setValue(buf + 8, p2.x, 'float'); // BR (bottom-right)
+            pdf.setValue(buf + 12, p2.y, 'float');
+            pdf.setValue(buf + 16, p4.x, 'float'); // TL (top-left)
+            pdf.setValue(buf + 20, p4.y, 'float');
+            pdf.setValue(buf + 24, p3.x, 'float'); // TR (top-right)
+            pdf.setValue(buf + 28, p3.y, 'float');
+        };
+        /* ----------------------------------------------------------------------- */
+        /* 1. overwrite the quads that already exist                               */
+        const min = Math.min(count, rects.length);
+        for (let i = 0; i < min; i++) {
+            writeQuad(rects[i]);
+            if (!this.pdfiumModule.FPDFAnnot_SetAttachmentPoints(annotPtr, i, buf)) {
+                this.free(buf);
+                return false;
+            }
+        }
+        /* 2. append new quads if rects.length > count                             */
+        for (let i = count; i < rects.length; i++) {
+            writeQuad(rects[i]);
+            if (!this.pdfiumModule.FPDFAnnot_AppendAttachmentPoints(annotPtr, buf)) {
+                this.free(buf);
+                return false;
+            }
+        }
+        this.free(buf);
+        return true;
+    }
+    /**
+     * Read ink list from annotation
+     * @param page  - logical page info object (`PdfPageObject`)
+     * @param annotationPtr - pointer to the annotation whose ink list is needed
+     * @returns ink list
+     */
+    getInkList(page, annotationPtr) {
+        const inkList = [];
+        const count = this.pdfiumModule.FPDFAnnot_GetInkListCount(annotationPtr);
+        for (let i = 0; i < count; i++) {
+            const points = [];
+            const pointsCount = this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, 0, 0);
+            if (pointsCount > 0) {
+                const pointMemorySize = 8;
+                const pointsPtr = this.malloc(pointsCount * pointMemorySize);
+                this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, pointsPtr, pointsCount);
+                for (let j = 0; j < pointsCount; j++) {
+                    const pointX = this.pdfiumModule.pdfium.getValue(pointsPtr + j * 8, 'float');
+                    const pointY = this.pdfiumModule.pdfium.getValue(pointsPtr + j * 8 + 4, 'float');
+                    const { x, y } = this.convertPagePointToDevicePoint(page, {
+                        x: pointX,
+                        y: pointY,
+                    });
+                    points.push({ x, y });
+                }
+                this.free(pointsPtr);
+            }
+            inkList.push({ points });
+        }
+        return inkList;
+    }
+    /**
+     * Add ink list to annotation
+     * @param page  - logical page info object (`PdfPageObject`)
+     * @param annotationPtr - pointer to the annotation whose ink list is needed
+     * @param annotation - annotation object (`PdfInkAnnoObject`)
+     * @returns `true` if the operation was successful
+     */
+    setInkList(page, annotationPtr, inkList) {
+        for (const inkStroke of inkList) {
+            const inkPointsCount = inkStroke.points.length;
+            const inkPointsPtr = this.malloc(inkPointsCount * 8);
+            for (let i = 0; i < inkPointsCount; i++) {
+                const point = inkStroke.points[i];
+                const { x, y } = this.convertDevicePointToPagePoint(page, point);
+                this.pdfiumModule.pdfium.setValue(inkPointsPtr + i * 8, x, 'float');
+                this.pdfiumModule.pdfium.setValue(inkPointsPtr + i * 8 + 4, y, 'float');
+            }
+            if (this.pdfiumModule.FPDFAnnot_AddInkStroke(annotationPtr, inkPointsPtr, inkPointsCount) === -1) {
+                this.free(inkPointsPtr);
+                return false;
+            }
+            this.free(inkPointsPtr);
+        }
+        return true;
     }
     /**
      * Read pdf text annotation
@@ -2485,30 +2678,23 @@ class PdfiumEngine {
      * @private
      */
     readPdfTextAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const annoRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, annoRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
+        const modified = models.pdfDateToDate(modifiedRaw);
         const contents = this.getAnnotString(annotationPtr, 'Contents') || '';
         const state = this.getAnnotString(annotationPtr, 'State');
         const stateModel = this.getAnnotString(annotationPtr, 'StateModel');
-        const color = this.resolveAnnotationColor(annotationPtr);
+        const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
         const inReplyToId = this.getInReplyToId(pagePtr, annotationPtr);
-        const popup = !inReplyToId
-            ? this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index)
-            : undefined;
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.TEXT,
             contents,
-            color,
+            ...webAlphaColor,
             rect,
-            popup,
-            appearances,
             inReplyToId,
             author,
             modified,
@@ -2527,16 +2713,13 @@ class PdfiumEngine {
      * @private
      */
     readPdfFreeTextAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const annoRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, annoRect);
         const contents = this.getAnnotString(annotationPtr, 'Contents') || '';
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.FREETEXT,
@@ -2544,8 +2727,6 @@ class PdfiumEngine {
             author,
             modified,
             rect,
-            popup,
-            appearances,
         };
     }
     /**
@@ -2565,13 +2746,12 @@ class PdfiumEngine {
         if (!linkPtr) {
             return;
         }
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const annoRect = this.readPageAnnoRect(annotationPtr);
         const { left, top, right, bottom } = annoRect;
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, annoRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
+        const modified = models.pdfDateToDate(modifiedRaw);
         const utf16Length = this.pdfiumModule.FPDFText_GetBoundedText(textPagePtr, left, top, right, bottom, 0, 0);
         const bytesCount = (utf16Length + 1) * 2; // include NIL
         const textBufferPtr = this.malloc(bytesCount);
@@ -2583,17 +2763,13 @@ class PdfiumEngine {
         }, () => {
             return this.pdfiumModule.FPDFLink_GetDest(docPtr, linkPtr);
         });
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.LINK,
             text,
             target,
             rect,
-            popup,
-            appearances,
             author,
             modified,
         };
@@ -2610,23 +2786,18 @@ class PdfiumEngine {
      * @private
      */
     readPdfWidgetAnno(page, pagePtr, annotationPtr, formHandle, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         const field = this.readPdfWidgetAnnoField(formHandle, annotationPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.WIDGET,
             rect,
             field,
-            popup,
-            appearances,
             author,
             modified,
         };
@@ -2642,21 +2813,16 @@ class PdfiumEngine {
      * @private
      */
     readPdfFileAttachmentAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.FILEATTACHMENT,
             rect,
-            popup,
-            appearances,
             author,
             modified,
         };
@@ -2672,44 +2838,22 @@ class PdfiumEngine {
      * @private
      */
     readPdfInkAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
-        const inkList = [];
-        const count = this.pdfiumModule.FPDFAnnot_GetInkListCount(annotationPtr);
-        for (let i = 0; i < count; i++) {
-            const points = [];
-            const pointsCount = this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, 0, 0);
-            if (pointsCount > 0) {
-                const pointMemorySize = 8;
-                const pointsPtr = this.malloc(pointsCount * pointMemorySize);
-                this.pdfiumModule.FPDFAnnot_GetInkListPath(annotationPtr, i, pointsPtr, pointsCount);
-                for (let j = 0; j < pointsCount; j++) {
-                    const pointX = this.pdfiumModule.pdfium.getValue(pointsPtr + j * 8, 'float');
-                    const pointY = this.pdfiumModule.pdfium.getValue(pointsPtr + j * 8 + 4, 'float');
-                    const { x, y } = this.convertPagePointToDevicePoint(page, {
-                        x: pointX,
-                        y: pointY,
-                    });
-                    points.push({ x, y });
-                }
-                this.free(pointsPtr);
-            }
-            inkList.push({ points });
-        }
+        const modified = models.pdfDateToDate(modifiedRaw);
+        const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
+        const { width: strokeWidth } = this.getBorderStyle(annotationPtr);
+        const inkList = this.getInkList(page, annotationPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.INK,
+            ...webAlphaColor,
+            strokeWidth,
             rect,
-            popup,
             inkList,
-            appearances,
             author,
             modified,
         };
@@ -2725,23 +2869,18 @@ class PdfiumEngine {
      * @private
      */
     readPdfPolygonAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         const vertices = this.readPdfAnnoVertices(page, pagePtr, annotationPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.POLYGON,
             rect,
-            popup,
             vertices,
-            appearances,
             author,
             modified,
         };
@@ -2757,23 +2896,18 @@ class PdfiumEngine {
      * @private
      */
     readPdfPolylineAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         const vertices = this.readPdfAnnoVertices(page, pagePtr, annotationPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.POLYLINE,
             rect,
-            popup,
             vertices,
-            appearances,
             author,
             modified,
         };
@@ -2789,13 +2923,11 @@ class PdfiumEngine {
      * @private
      */
     readPdfLineAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         const startPointPtr = this.malloc(8);
         const endPointPtr = this.malloc(8);
         this.pdfiumModule.FPDFAnnot_GetLine(annotationPtr, startPointPtr, endPointPtr);
@@ -2814,15 +2946,12 @@ class PdfiumEngine {
         this.free(startPointPtr);
         this.free(endPointPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.LINE,
             rect,
-            popup,
             startPoint,
             endPoint,
-            appearances,
             author,
             modified,
         };
@@ -2838,25 +2967,22 @@ class PdfiumEngine {
      * @private
      */
     readPdfHighlightAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
-        const quads = this.readAnnotationQuads(page, annotationPtr);
-        const color = this.resolveAnnotationColor(annotationPtr);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
+        const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
+        const modified = models.pdfDateToDate(modifiedRaw);
+        const contents = this.getAnnotString(annotationPtr, 'Contents') || '';
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.HIGHLIGHT,
             rect,
-            popup,
-            appearances,
-            segmentRects: quads.map(models.quadToRect),
-            color,
+            contents,
+            segmentRects,
+            ...webAlphaColor,
             author,
             modified,
         };
@@ -2872,21 +2998,22 @@ class PdfiumEngine {
      * @private
      */
     readPdfUnderlineAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
+        const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
+        const contents = this.getAnnotString(annotationPtr, 'Contents') || '';
+        const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.UNDERLINE,
             rect,
-            popup,
-            appearances,
+            contents,
+            segmentRects,
+            ...webAlphaColor,
             author,
             modified,
         };
@@ -2902,21 +3029,22 @@ class PdfiumEngine {
      * @private
      */
     readPdfStrikeOutAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
+        const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
+        const contents = this.getAnnotString(annotationPtr, 'Contents') || '';
+        const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.STRIKEOUT,
             rect,
-            popup,
-            appearances,
+            contents,
+            segmentRects,
+            ...webAlphaColor,
             author,
             modified,
         };
@@ -2932,21 +3060,22 @@ class PdfiumEngine {
      * @private
      */
     readPdfSquigglyAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
+        const segmentRects = this.getQuadPointsAnno(page, annotationPtr);
+        const contents = this.getAnnotString(annotationPtr, 'Contents') || '';
+        const webAlphaColor = this.resolveAnnotationColor(annotationPtr);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.SQUIGGLY,
             rect,
-            popup,
-            appearances,
+            contents,
+            segmentRects,
+            ...webAlphaColor,
             author,
             modified,
         };
@@ -2962,21 +3091,16 @@ class PdfiumEngine {
      * @private
      */
     readPdfCaretAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.CARET,
             rect,
-            popup,
-            appearances,
             author,
             modified,
         };
@@ -2993,13 +3117,11 @@ class PdfiumEngine {
      * @private
      */
     readPdfStampAnno(docPtr, page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         const contents = [];
         const objectCount = this.pdfiumModule.FPDFAnnot_GetObjectCount(annotationPtr);
         for (let i = 0; i < objectCount; i++) {
@@ -3010,14 +3132,11 @@ class PdfiumEngine {
             }
         }
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.STAMP,
             rect,
-            popup,
             contents,
-            appearances,
             author,
             modified,
         };
@@ -3186,6 +3305,39 @@ class PdfiumEngine {
         this.free(matrixPtr);
         return { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
     }
+    /**
+     * Return the stroke-width declared in the annotation’s /Border or /BS entry.
+     * Falls back to 1 pt when nothing is defined.
+     *
+     * @param annotationPtr - pointer to pdf annotation
+     * @returns stroke-width
+     *
+     * @private
+     */
+    getStrokeWidth(annotationPtr) {
+        // FPDFAnnot_GetBorder(annot, &hRadius, &vRadius, &borderWidth)
+        const hPtr = this.malloc(4);
+        const vPtr = this.malloc(4);
+        const wPtr = this.malloc(4);
+        const ok = this.pdfiumModule.FPDFAnnot_GetBorder(annotationPtr, hPtr, vPtr, wPtr);
+        const width = ok ? this.pdfiumModule.pdfium.getValue(wPtr, 'float') : 1; // default 1 pt
+        this.free(hPtr);
+        this.free(vPtr);
+        this.free(wPtr);
+        return width;
+    }
+    /**
+     * Fetches the `/F` flag bit-field from an annotation.
+     *
+     * @param annotationPtr pointer to an `FPDF_ANNOTATION`
+     * @returns `{ raw, flags }`
+     *          • `raw`   – the 32-bit integer returned by PDFium
+     *          • `flags` – object with individual booleans
+     */
+    getAnnotationFlags(annotationPtr) {
+        const rawFlags = this.pdfiumModule.FPDFAnnot_GetFlags(annotationPtr); // number
+        return models.flagsToNames(rawFlags);
+    }
     /**
      * Read circle annotation
      * @param page  - pdf page infor
@@ -3197,23 +3349,51 @@ class PdfiumEngine {
      * @private
      */
     readPdfCircleAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
+        const flags = this.getAnnotationFlags(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
+        const { color, opacity } = this.resolveAnnotationColor(annotationPtr, models.PdfAnnotationColorType.InteriorColor);
+        const { color: strokeColor } = this.resolveAnnotationColor(annotationPtr);
+        let { style: strokeStyle, width: strokeWidth } = this.getBorderStyle(annotationPtr);
+        let cloudyBorderIntensity;
+        let cloudyBorderInset;
+        if (strokeStyle === models.PdfAnnotationBorderStyle.CLOUDY ||
+            strokeStyle === models.PdfAnnotationBorderStyle.UNKNOWN) {
+            const { ok: hasEffect, intensity } = this.getBorderEffect(annotationPtr);
+            if (hasEffect) {
+                cloudyBorderIntensity = intensity;
+                strokeStyle = models.PdfAnnotationBorderStyle.CLOUDY;
+                const { ok: hasInset, left, top, right, bottom, } = this.getRectangleDifferences(annotationPtr);
+                if (hasInset)
+                    cloudyBorderInset = [left, top, right, bottom];
+            }
+        }
+        let strokeDashArray;
+        if (strokeStyle === models.PdfAnnotationBorderStyle.DASHED) {
+            const { ok, pattern } = this.getBorderDashPattern(annotationPtr);
+            if (ok) {
+                strokeDashArray = pattern;
+            }
+        }
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.CIRCLE,
+            flags,
+            color,
+            opacity,
+            strokeWidth,
+            strokeColor,
+            strokeStyle,
             rect,
-            popup,
-            appearances,
             author,
             modified,
+            ...(cloudyBorderIntensity !== undefined && { cloudyBorderIntensity }),
+            ...(cloudyBorderInset !== undefined && { cloudyBorderInset }),
+            ...(strokeDashArray !== undefined && { strokeDashArray }),
         };
     }
     /**
@@ -3227,23 +3407,51 @@ class PdfiumEngine {
      * @private
      */
     readPdfSquareAnno(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
+        const flags = this.getAnnotationFlags(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
+        const { color, opacity } = this.resolveAnnotationColor(annotationPtr, models.PdfAnnotationColorType.InteriorColor);
+        const { color: strokeColor } = this.resolveAnnotationColor(annotationPtr);
+        let { style: strokeStyle, width: strokeWidth } = this.getBorderStyle(annotationPtr);
+        let cloudyBorderIntensity;
+        let cloudyBorderInset;
+        if (strokeStyle === models.PdfAnnotationBorderStyle.CLOUDY ||
+            strokeStyle === models.PdfAnnotationBorderStyle.UNKNOWN) {
+            const { ok: hasEffect, intensity } = this.getBorderEffect(annotationPtr);
+            if (hasEffect) {
+                cloudyBorderIntensity = intensity;
+                strokeStyle = models.PdfAnnotationBorderStyle.CLOUDY;
+                const { ok: hasInset, left, top, right, bottom, } = this.getRectangleDifferences(annotationPtr);
+                if (hasInset)
+                    cloudyBorderInset = [left, top, right, bottom];
+            }
+        }
+        let strokeDashArray;
+        if (strokeStyle === models.PdfAnnotationBorderStyle.DASHED) {
+            const { ok, pattern } = this.getBorderDashPattern(annotationPtr);
+            if (ok) {
+                strokeDashArray = pattern;
+            }
+        }
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type: models.PdfAnnotationSubtype.SQUARE,
+            flags,
+            color,
+            opacity,
+            strokeColor,
+            strokeWidth,
+            strokeStyle,
             rect,
-            popup,
-            appearances,
             author,
             modified,
+            ...(cloudyBorderIntensity !== undefined && { cloudyBorderIntensity }),
+            ...(cloudyBorderInset !== undefined && { cloudyBorderInset }),
+            ...(strokeDashArray !== undefined && { strokeDashArray }),
         };
     }
     /**
@@ -3258,21 +3466,16 @@ class PdfiumEngine {
      * @private
      */
     readPdfAnno(page, pagePtr, type, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
         const pageRect = this.readPageAnnoRect(annotationPtr);
         const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
         const author = this.getAnnotString(annotationPtr, 'T');
         const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const popup = this.readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index);
+        const modified = models.pdfDateToDate(modifiedRaw);
         return {
-            status: models.PdfAnnotationObjectStatus.Committed,
             pageIndex: page.index,
             id: index,
             type,
             rect,
-            popup,
-            appearances,
             author,
             modified,
         };
@@ -3294,25 +3497,6 @@ class PdfiumEngine {
         const idx = this.pdfiumModule.FPDFPage_GetAnnotIndex(pagePtr, parentPtr);
         return idx >= 0 ? idx : undefined;
     }
-    /**
-     * Parse a PDF date string **D:YYYYMMDDHHmmSSOHH'mm'** to ISO-8601.
-     *
-     * Returns `undefined` if the input is malformed.
-     *
-     * @private
-     */
-    toIsoDate(pdfDate) {
-        if (!pdfDate?.startsWith('D:'))
-            return;
-        // Minimal parse – ignore timezone for brevity
-        const y = pdfDate.substring(2, 6);
-        const m = pdfDate.substring(6, 8) || '01';
-        const d = pdfDate.substring(8, 10) || '01';
-        const H = pdfDate.substring(10, 12) || '00';
-        const M = pdfDate.substring(12, 14) || '00';
-        const S = pdfDate.substring(14, 16) || '00';
-        return `${y}-${m}-${d}T${H}:${M}:${S}`;
-    }
     /**
      * Fetch a string value (`/T`, `/M`, `/State`, …) from an annotation.
      *
@@ -3332,41 +3516,19 @@ class PdfiumEngine {
         return value || undefined;
     }
     /**
-     * Read linked popup of pdf annotation
-     * @param page  - pdf page infor
-     * @param pagePtr - pointer to pdf page object
-     * @param annotationPtr - pointer to pdf annotation
-     * @param index  - index of annotation in the pdf page
-     * @returns pdf popup linked to annotation
+     * Set a string value (`/T`, `/M`, `/State`, …) to an annotation.
+     *
+     * @returns `true` if the operation was successful
      *
      * @private
      */
-    readPdfAnnoLinkedPopup(page, pagePtr, annotationPtr, index) {
-        const appearances = this.readPageAnnoAppearanceStreams(annotationPtr);
-        const popupAnnotationPtr = this.pdfiumModule.FPDFAnnot_GetLinkedAnnot(annotationPtr, 'Popup');
-        if (!popupAnnotationPtr) {
-            return;
-        }
-        const pageRect = this.readPageAnnoRect(popupAnnotationPtr);
-        const rect = this.convertPageRectToDeviceRect(page, pagePtr, pageRect);
-        const author = this.getAnnotString(annotationPtr, 'T');
-        const modifiedRaw = this.getAnnotString(annotationPtr, 'M');
-        const modified = this.toIsoDate(modifiedRaw);
-        const contents = this.getAnnotString(annotationPtr, 'Contents') || '';
-        const open = this.getAnnotString(annotationPtr, 'Open') || 'false';
-        this.pdfiumModule.FPDFPage_CloseAnnot(popupAnnotationPtr);
-        return {
-            status: models.PdfAnnotationObjectStatus.Committed,
-            pageIndex: page.index,
-            id: index,
-            type: models.PdfAnnotationSubtype.POPUP,
-            rect,
-            contents,
-            open: open === 'true',
-            appearances,
-            author,
-            modified,
-        };
+    setAnnotString(annotationPtr, key, value) {
+        const bytes = 2 * (value.length + 1);
+        const ptr = this.malloc(bytes);
+        this.pdfiumModule.pdfium.stringToUTF16(value, ptr, bytes);
+        const ok = this.pdfiumModule.FPDFAnnot_SetStringValue(annotationPtr, key, ptr);
+        this.free(ptr);
+        return ok;
     }
     /**
      * Read vertices of pdf annotation
@@ -3475,6 +3637,81 @@ class PdfiumEngine {
             options,
         };
     }
+    /**
+     * {@inheritDoc @embedpdf/models!PdfEngine.renderAnnotation}
+     *
+     * @public
+     */
+    renderAnnotation(doc, page, annotation, scaleFactor, rotation, dpr = 1, // device-pixel-ratio (canvas)
+    mode = models.AppearanceMode.Normal, imageType = 'image/webp') {
+        this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, 'renderAnnotation', doc, page, annotation, scaleFactor, rotation, dpr, mode, imageType);
+        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `RenderAnnotation`, 'Begin', `${doc.id}-${page.index}-${annotation.id}`);
+        const task = new models.Task();
+        const ctx = this.cache.getContext(doc.id);
+        if (!ctx) {
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `RenderAnnotation`, 'End', `${doc.id}-${page.index}-${annotation.id}`);
+            return models.PdfTaskHelper.reject({
+                code: models.PdfErrorCode.DocNotOpen,
+                message: 'document does not open',
+            });
+        }
+        /* ── 1. grab native handles ───────────────────────────────────────── */
+        const pageCtx = ctx.acquirePage(page.index);
+        const annotPtr = this.pdfiumModule.FPDFPage_GetAnnot(pageCtx.pagePtr, annotation.id);
+        if (!annotPtr) {
+            pageCtx.release();
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `RenderAnnotation`, 'End', `${doc.id}-${page.index}-${annotation.id}`);
+            return models.PdfTaskHelper.reject({
+                code: models.PdfErrorCode.NotFound,
+                message: 'annotation not found',
+            });
+        }
+        const finalScale = scaleFactor * dpr;
+        /* ── 2. decide bitmap size (integer pixels) ──────────────────────── */
+        const annotRect = annotation.rect;
+        const bitmapRect = models.toIntRect(models.transformRect(page.size, annotRect, rotation, finalScale));
+        const format = exports.BitmapFormat.Bitmap_BGRA;
+        const bytesPerPixel = 4;
+        const bitmapHeapLength = bitmapRect.size.width * bitmapRect.size.height * bytesPerPixel;
+        const bitmapHeapPtr = this.malloc(bitmapHeapLength);
+        const bitmapPtr = this.pdfiumModule.FPDFBitmap_CreateEx(bitmapRect.size.width, bitmapRect.size.height, format, bitmapHeapPtr, bitmapRect.size.width * bytesPerPixel);
+        this.pdfiumModule.FPDFBitmap_FillRect(bitmapPtr, 0, 0, bitmapRect.size.width, bitmapRect.size.height, 0x00000000);
+        const matrix = models.makeMatrix(annotation.rect, rotation, finalScale);
+        // Allocate memory for the matrix on the wasm heap and write to it
+        const matrixSize = 6 * 4;
+        const matrixPtr = this.malloc(matrixSize);
+        const matrixView = new Float32Array(this.pdfiumModule.pdfium.HEAPF32.buffer, matrixPtr, 6);
+        matrixView.set([matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f]);
+        /* ── 5. call the native helper with the new matrix ───────────────── */
+        const FLAGS = exports.RenderFlag.REVERSE_BYTE_ORDER;
+        const ok = !!this.pdfiumModule.EPDF_RenderAnnotBitmap(bitmapPtr, pageCtx.pagePtr, annotPtr, mode, matrixPtr, FLAGS);
+        /* ── 6. tear down native resources ───────────────────────────────── */
+        this.free(matrixPtr); // Free the matrix memory
+        this.pdfiumModule.FPDFBitmap_Destroy(bitmapPtr);
+        this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
+        pageCtx.release();
+        if (!ok) {
+            this.free(bitmapHeapPtr);
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `RenderAnnotation`, 'End', `${doc.id}-${page.index}-${annotation.id}`);
+            return models.PdfTaskHelper.reject({
+                code: models.PdfErrorCode.Unknown,
+                message: 'EPDF_RenderAnnotBitmap failed',
+            });
+        }
+        /* ── 6. copy out + convert to Blob (reuse existing converter) ─────── */
+        const data = this.pdfiumModule.pdfium.HEAPU8.subarray(bitmapHeapPtr, bitmapHeapPtr + bitmapHeapLength);
+        const imageData = {
+            data: new Uint8ClampedArray(data),
+            width: bitmapRect.size.width,
+            height: bitmapRect.size.height,
+        };
+        this.free(bitmapHeapPtr);
+        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, `RenderAnnotation`, 'End', `${doc.id}-${page.index}-${annotation.id}`);
+        this.imageDataConverter(imageData, imageType)
+            .then((blob) => task.resolve(blob))
+            .catch((err) => task.reject({ code: models.PdfErrorCode.Unknown, message: String(err) }));
+        return task;
+    }
     /**
      * render rectangle of pdf page to image
      * @param docPtr - pointer to pdf document object
@@ -3807,6 +4044,64 @@ 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$1, LOG_CATEGORY$1, 'setAnnotationColor', doc, page, annotation, color, which);
+        this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'setAnnotationColor', 'Begin', doc.id);
+        const task = models.PdfTaskHelper.create();
+        try {
+            /* 1 ── sanity & native handles ────────────────────────────────────────── */
+            const ctx = this.cache.getContext(doc.id);
+            if (!ctx) {
+                this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'setAnnotationColor', 'End', doc.id);
+                this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, '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$1, LOG_CATEGORY$1, 'setAnnotationColor', 'End', doc.id);
+                this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, 'setAnnotationColor: annot not found');
+                pageCtx.release();
+                task.resolve(false);
+                return task;
+            }
+            const ok = this.setAnnotationColor(annotPtr, color, which);
+            /* 4 ── regenerate appearance & clean-up ───────────────────────────────── */
+            if (ok) {
+                this.pdfiumModule.FPDFPage_GenerateContent(pageCtx.pagePtr);
+            }
+            this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
+            pageCtx.release();
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'setAnnotationColor', 'End', doc.id);
+            task.resolve(!!ok);
+        }
+        catch (error) {
+            this.logger.perf(LOG_SOURCE$1, LOG_CATEGORY$1, 'setAnnotationColor', 'End', doc.id);
+            this.logger.error(LOG_SOURCE$1, LOG_CATEGORY$1, 'setAnnotationColor: error', error);
+            task.reject({
+                code: models.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
@@ -4142,7 +4437,7 @@ class EngineRunner {
                     type: 'reject',
                     reason: {
                         code: models.PdfErrorCode.NotSupport,
-                        message: 'engine method has not supported yet',
+                        message: `engine method ${name} is not supported yet`,
                     },
                 };
                 const response = {
@@ -4197,6 +4492,9 @@ class EngineRunner {
                 case 'renderPageRect':
                     task = this.engine[name](...args);
                     break;
+                case 'renderAnnotation':
+                    task = this.engine[name](...args);
+                    break;
                 case 'renderThumbnail':
                     task = this.engine[name](...args);
                     break;
@@ -4209,12 +4507,15 @@ class EngineRunner {
                 case 'createPageAnnotation':
                     task = this.engine[name](...args);
                     break;
-                case 'transformPageAnnotation':
+                case 'updatePageAnnotation':
                     task = this.engine[name](...args);
                     break;
                 case 'removePageAnnotation':
                     task = this.engine[name](...args);
                     break;
+                case 'updateAnnotationColor':
+                    task = this.engine[name](...args);
+                    break;
                 case 'getPageTextRects':
                     task = this.engine[name](...args);
                     break;