@embedpdf/engines 2.9.1 → 2.10.0

package/dist/{direct-engine-D-Jf9yyY.js → direct-engine-4LZYs06h.js}

@@ -1,6 +1,6 @@
 import { init } from "@embedpdf/pdfium";
-import { Rotation, NoopLogger, PdfTaskHelper, PdfErrorCode, pdfDateToDate, isUuidV4, uuidV4, PdfAnnotationSubtype, PdfPageFlattenFlag, stripPdfUnwantedMarkers, PdfAnnotationIcon, PdfAnnotationColorType, PdfAnnotationBorderStyle, PdfAnnotationLineEnding, PdfStandardFont, PdfStampFit, PdfTrappedStatus, pdfColorToWebColor, webColorToPdfColor, pdfAlphaToWebOpacity, webOpacityToPdfAlpha, PdfAnnotationReplyType, dateToPdfDate, quadToRect, rectToQuad, PdfPageObjectType, flagsToNames, namesToFlags, PDF_FORM_FIELD_TYPE, AppearanceMode, Task, toIntRect, transformRect, buildUserToDeviceMatrix, AP_MODE_NORMAL, AP_MODE_ROLLOVER, AP_MODE_DOWN, PdfZoomMode, PdfActionType } from "@embedpdf/models";
-import { P as PdfEngine } from "./pdf-engine-ZvReuoDb.js";
+import { Rotation, NoopLogger, PdfTaskHelper, PdfErrorCode, pdfDateToDate, PdfJavaScriptActionTrigger, PdfAnnotationSubtype, isUuidV4, uuidV4, PdfJavaScriptWidgetEventType, PDF_ANNOT_AACTION_EVENT, PDF_FORM_FIELD_TYPE, PdfPageFlattenFlag, stripPdfUnwantedMarkers, PdfAnnotationIcon, PdfAnnotationColorType, PdfAnnotationBorderStyle, PdfStandardFont, PDF_FORM_FIELD_FLAG, webColorToPdfColor, pdfColorToWebColor, PdfAnnotationLineEnding, PdfStampFit, PdfTrappedStatus, pdfAlphaToWebOpacity, webOpacityToPdfAlpha, PdfAnnotationReplyType, dateToPdfDate, quadToRect, rectToQuad, PdfPageObjectType, flagsToNames, namesToFlags, AppearanceMode, Task, toIntRect, transformRect, buildUserToDeviceMatrix, AP_MODE_NORMAL, AP_MODE_ROLLOVER, AP_MODE_DOWN, PdfZoomMode, PdfActionType } from "@embedpdf/models";
+import { P as PdfEngine } from "./pdf-engine-sORqXhQk.js";
 import { b as browserImageDataToBlobConverter } from "./browser-BISJ9naB.js";
 function readString(wasmModule, readChars, parseChars, defaultLength = 100) {
   let buffer = wasmModule.wasmExports.malloc(defaultLength);
@@ -335,13 +335,6 @@ class PageContext {
     if (this.textPagePtr !== void 0) {
       this.pdf.FPDFText_ClosePage(this.textPagePtr);
     }
-    if (this.formHandle !== void 0) {
-      this.pdf.FORM_OnBeforeClosePage(this.pagePtr, this.formHandle);
-      this.pdf.PDFiumExt_ExitFormFillEnvironment(this.formHandle);
-    }
-    if (this.formInfoPtr !== void 0) {
-      this.pdf.PDFiumExt_CloseFormFillInfo(this.formInfoPtr);
-    }
     this.pdf.FPDF_ClosePage(this.pagePtr);
     this.onFinalDispose();
   }
@@ -354,16 +347,6 @@ class PageContext {
     }
     return this.textPagePtr;
   }
-  /** Always safe: opens (once) and returns the form-fill handle. */
-  getFormHandle() {
-    this.ensureAlive();
-    if (this.formHandle === void 0) {
-      this.formInfoPtr = this.pdf.PDFiumExt_OpenFormFillInfo();
-      this.formHandle = this.pdf.PDFiumExt_InitFormFillEnvironment(this.docPtr, this.formInfoPtr);
-      this.pdf.FORM_OnAfterLoadPage(this.pagePtr, this.formHandle);
-    }
-    return this.formHandle;
-  }
   /**
    * Safely execute `fn` with an annotation pointer.
    * Pointer is ALWAYS closed afterwards.
@@ -377,6 +360,23 @@ class PageContext {
       this.pdf.FPDFPage_CloseAnnot(annotPtr);
     }
   }
+  /**
+   * Safely execute `fn` with a fresh form-fill handle.
+   * Handle is ALWAYS torn down afterwards — no caching, no stale state.
+   */
+  withFormHandle(fn) {
+    this.ensureAlive();
+    const formInfoPtr = this.pdf.PDFiumExt_OpenFormFillInfo();
+    const formHandle = this.pdf.PDFiumExt_InitFormFillEnvironment(this.docPtr, formInfoPtr);
+    this.pdf.FORM_OnAfterLoadPage(this.pagePtr, formHandle);
+    try {
+      return fn(formHandle);
+    } finally {
+      this.pdf.FORM_OnBeforeClosePage(this.pagePtr, formHandle);
+      this.pdf.PDFiumExt_ExitFormFillEnvironment(formHandle);
+      this.pdf.PDFiumExt_CloseFormFillInfo(formInfoPtr);
+    }
+  }
   ensureAlive() {
     if (this.disposed) throw new Error("PageContext already disposed");
   }
@@ -1452,6 +1452,202 @@ class PdfiumNative {
     this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `RenderPageRect`, "End", `${doc.id}-${page.index}`);
     return task;
   }
+  getDocumentJavaScriptActions(doc) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getDocumentJavaScriptActions", doc);
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const count = this.pdfiumModule.FPDFDoc_GetJavaScriptActionCount(ctx.docPtr);
+    if (count < 0) {
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.Unknown,
+        message: "failed to read document javascript actions"
+      });
+    }
+    const actions = [];
+    for (let index = 0; index < count; index++) {
+      const actionPtr = this.pdfiumModule.FPDFDoc_GetJavaScriptAction(ctx.docPtr, index);
+      if (!actionPtr) continue;
+      try {
+        const name = readString(
+          this.pdfiumModule.pdfium,
+          (buffer, bufferLength) => this.pdfiumModule.FPDFJavaScriptAction_GetName(actionPtr, buffer, bufferLength),
+          this.pdfiumModule.pdfium.UTF16ToString
+        ) ?? "";
+        const script = readString(
+          this.pdfiumModule.pdfium,
+          (buffer, bufferLength) => this.pdfiumModule.FPDFJavaScriptAction_GetScript(actionPtr, buffer, bufferLength),
+          this.pdfiumModule.pdfium.UTF16ToString
+        ) ?? "";
+        if (!script) continue;
+        actions.push({
+          id: `document:${index}:${name}`,
+          trigger: PdfJavaScriptActionTrigger.DocumentNamed,
+          name,
+          script
+        });
+      } finally {
+        this.pdfiumModule.FPDFDoc_CloseJavaScriptAction(actionPtr);
+      }
+    }
+    return PdfTaskHelper.resolve(actions);
+  }
+  getPageAnnoWidgets(doc, page) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getPageAnnoWidgets", doc, page);
+    this.logger.perf(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      `GetPageAnnoWidgets`,
+      "Begin",
+      `${doc.id}-${page.index}`
+    );
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      this.logger.perf(
+        LOG_SOURCE,
+        LOG_CATEGORY,
+        `GetPageAnnoWidgets`,
+        "End",
+        `${doc.id}-${page.index}`
+      );
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const annotationWidgets = this.readPageAnnoWidgets(doc, ctx, page);
+    this.logger.perf(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      `GetPageAnnoWidgets`,
+      "End",
+      `${doc.id}-${page.index}`
+    );
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      `GetPageAnnoWidgets`,
+      `${doc.id}-${page.index}`,
+      annotationWidgets
+    );
+    return PdfTaskHelper.resolve(annotationWidgets);
+  }
+  getPageWidgetJavaScriptActions(doc, page) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "getPageWidgetJavaScriptActions", doc, page);
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const actions = [];
+    ctx.borrowPage(page.index, (pageCtx) => {
+      pageCtx.withFormHandle((formHandle) => {
+        const annotCount = this.pdfiumModule.FPDFPage_GetAnnotCount(pageCtx.pagePtr);
+        for (let i = 0; i < annotCount; i++) {
+          pageCtx.withAnnotation(i, (annotPtr) => {
+            const subtype = this.pdfiumModule.FPDFAnnot_GetSubtype(
+              annotPtr
+            );
+            if (subtype !== PdfAnnotationSubtype.WIDGET) return;
+            let annotationId = this.getAnnotString(annotPtr, "NM");
+            if (!annotationId || !isUuidV4(annotationId)) {
+              annotationId = uuidV4();
+              this.setAnnotString(annotPtr, "NM", annotationId);
+            }
+            const fieldName = readString(
+              this.pdfiumModule.pdfium,
+              (buffer, bufferLength) => this.pdfiumModule.FPDFAnnot_GetFormFieldName(
+                formHandle,
+                annotPtr,
+                buffer,
+                bufferLength
+              ),
+              this.pdfiumModule.pdfium.UTF16ToString
+            ) ?? "";
+            const eventConfigs = [
+              {
+                event: PDF_ANNOT_AACTION_EVENT.KEY_STROKE,
+                eventType: PdfJavaScriptWidgetEventType.Keystroke,
+                trigger: PdfJavaScriptActionTrigger.WidgetKeystroke
+              },
+              {
+                event: PDF_ANNOT_AACTION_EVENT.FORMAT,
+                eventType: PdfJavaScriptWidgetEventType.Format,
+                trigger: PdfJavaScriptActionTrigger.WidgetFormat
+              },
+              {
+                event: PDF_ANNOT_AACTION_EVENT.VALIDATE,
+                eventType: PdfJavaScriptWidgetEventType.Validate,
+                trigger: PdfJavaScriptActionTrigger.WidgetValidate
+              },
+              {
+                event: PDF_ANNOT_AACTION_EVENT.CALCULATE,
+                eventType: PdfJavaScriptWidgetEventType.Calculate,
+                trigger: PdfJavaScriptActionTrigger.WidgetCalculate
+              }
+            ];
+            for (const config of eventConfigs) {
+              const script = readString(
+                this.pdfiumModule.pdfium,
+                (buffer, bufferLength) => this.pdfiumModule.FPDFAnnot_GetFormAdditionalActionJavaScript(
+                  formHandle,
+                  annotPtr,
+                  config.event,
+                  buffer,
+                  bufferLength
+                ),
+                this.pdfiumModule.pdfium.UTF16ToString
+              ) ?? "";
+              if (!script) continue;
+              actions.push({
+                id: `widget:${page.index}:${annotationId}:${config.eventType}`,
+                trigger: config.trigger,
+                eventType: config.eventType,
+                pageIndex: page.index,
+                annotationId,
+                fieldName,
+                script
+              });
+            }
+          });
+        }
+      });
+    });
+    return PdfTaskHelper.resolve(actions);
+  }
+  regenerateWidgetAppearances(doc, page, annotationIds) {
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const idSet = new Set(annotationIds);
+    let regenerated = 0;
+    ctx.borrowPage(page.index, (pageCtx) => {
+      const count = this.pdfiumModule.FPDFPage_GetAnnotCount(pageCtx.pagePtr);
+      for (let i = 0; i < count; i++) {
+        pageCtx.withAnnotation(i, (annotPtr) => {
+          const nm = this.getAnnotString(annotPtr, "NM");
+          if (nm && idSet.has(nm)) {
+            this.pdfiumModule.EPDFAnnot_GenerateFormFieldAP(annotPtr);
+            regenerated++;
+          }
+        });
+      }
+      if (regenerated > 0) {
+        this.pdfiumModule.FPDFPage_GenerateContent(pageCtx.pagePtr);
+      }
+    });
+    return PdfTaskHelper.resolve(regenerated > 0);
+  }
   /**
    * {@inheritDoc @embedpdf/models!PdfEngine.getPageAnnotations}
    *
@@ -1503,6 +1699,7 @@ class PdfiumNative {
    * @public
    */
   createPageAnnotation(doc, page, annotation, context) {
+    var _a;
     this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "createPageAnnotation", doc, page, annotation);
     this.logger.perf(
       LOG_SOURCE,
@@ -1526,7 +1723,30 @@ class PdfiumNative {
       });
     }
     const pageCtx = ctx.acquirePage(page.index);
-    const annotationPtr = this.pdfiumModule.EPDFPage_CreateAnnot(pageCtx.pagePtr, annotation.type);
+    let annotationPtr;
+    let widgetFormInfoPtr;
+    let widgetFormHandle;
+    if (annotation.type === PdfAnnotationSubtype.WIDGET) {
+      const widget = annotation;
+      widgetFormInfoPtr = this.pdfiumModule.PDFiumExt_OpenFormFillInfo();
+      widgetFormHandle = this.pdfiumModule.PDFiumExt_InitFormFillEnvironment(
+        ctx.docPtr,
+        widgetFormInfoPtr
+      );
+      this.pdfiumModule.FORM_OnAfterLoadPage(pageCtx.pagePtr, widgetFormHandle);
+      const fieldName = ((_a = widget.field) == null ? void 0 : _a.name) ?? "";
+      annotationPtr = this.withWString(
+        fieldName,
+        (namePtr) => this.pdfiumModule.EPDFPage_CreateFormField(
+          pageCtx.pagePtr,
+          widgetFormHandle,
+          widget.field.type,
+          namePtr
+        )
+      );
+    } else {
+      annotationPtr = this.pdfiumModule.EPDFPage_CreateAnnot(pageCtx.pagePtr, annotation.type);
+    }
     if (!annotationPtr) {
       this.logger.perf(
         LOG_SOURCE,
@@ -1671,6 +1891,32 @@ class PdfiumNative {
           saveAnnotation
         );
         break;
+      case PdfAnnotationSubtype.WIDGET: {
+        const widget = saveAnnotation;
+        if (widgetFormHandle !== void 0) {
+          switch (widget.field.type) {
+            case PDF_FORM_FIELD_TYPE.TEXTFIELD:
+              isSucceed = this.addTextFieldContent(widgetFormHandle, annotationPtr, widget);
+              break;
+            case PDF_FORM_FIELD_TYPE.CHECKBOX:
+            case PDF_FORM_FIELD_TYPE.RADIOBUTTON:
+              isSucceed = this.addToggleFieldContent(widgetFormHandle, annotationPtr, widget);
+              break;
+            case PDF_FORM_FIELD_TYPE.COMBOBOX:
+            case PDF_FORM_FIELD_TYPE.LISTBOX:
+              isSucceed = this.addChoiceFieldContent(widgetFormHandle, annotationPtr, widget);
+              break;
+          }
+        }
+        break;
+      }
+    }
+    if (widgetFormHandle !== void 0) {
+      this.pdfiumModule.FORM_OnBeforeClosePage(pageCtx.pagePtr, widgetFormHandle);
+      this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(widgetFormHandle);
+    }
+    if (widgetFormInfoPtr !== void 0) {
+      this.pdfiumModule.PDFiumExt_CloseFormFillInfo(widgetFormInfoPtr);
     }
     if (!isSucceed) {
       this.pdfiumModule.FPDFPage_RemoveAnnot(pageCtx.pagePtr, annotationPtr);
@@ -1687,7 +1933,9 @@ class PdfiumNative {
         message: "can not add content of the annotation"
       });
     }
-    if (annotation.blendMode !== void 0) {
+    if (annotation.type === PdfAnnotationSubtype.WIDGET) {
+      this.pdfiumModule.EPDFAnnot_GenerateFormFieldAP(annotationPtr);
+    } else if (annotation.blendMode !== void 0) {
       this.pdfiumModule.EPDFAnnot_GenerateAppearanceWithBlend(annotationPtr, annotation.blendMode);
     } else {
       this.pdfiumModule.EPDFAnnot_GenerateAppearance(annotationPtr);
@@ -1889,12 +2137,34 @@ class PdfiumNative {
         );
         break;
       }
+      /* ── Widget (form field) ─────────────────────────────────────────────── */
+      case PdfAnnotationSubtype.WIDGET: {
+        const widget = saveAnnotation;
+        pageCtx.withFormHandle((formHandle) => {
+          switch (widget.field.type) {
+            case PDF_FORM_FIELD_TYPE.TEXTFIELD:
+              ok = this.addTextFieldContent(formHandle, annotPtr, widget);
+              break;
+            case PDF_FORM_FIELD_TYPE.CHECKBOX:
+            case PDF_FORM_FIELD_TYPE.RADIOBUTTON:
+              ok = this.addToggleFieldContent(formHandle, annotPtr, widget);
+              break;
+            case PDF_FORM_FIELD_TYPE.COMBOBOX:
+            case PDF_FORM_FIELD_TYPE.LISTBOX:
+              ok = this.addChoiceFieldContent(formHandle, annotPtr, widget);
+              break;
+          }
+        });
+        break;
+      }
       /* ── Unsupported edits – fall through to error ───────────────────────── */
       default:
         ok = false;
     }
     if (ok && (options == null ? void 0 : options.regenerateAppearance) !== false) {
-      if (annotation.blendMode !== void 0) {
+      if (annotation.type === PdfAnnotationSubtype.WIDGET) {
+        this.pdfiumModule.EPDFAnnot_GenerateFormFieldAP(annotPtr);
+      } else if (annotation.blendMode !== void 0) {
         this.pdfiumModule.EPDFAnnot_GenerateAppearanceWithBlend(annotPtr, annotation.blendMode);
       } else {
         this.pdfiumModule.EPDFAnnot_GenerateAppearance(annotPtr);
@@ -2258,156 +2528,376 @@ class PdfiumNative {
         message: "document does not open"
       });
     }
-    const formFillInfoPtr = this.pdfiumModule.PDFiumExt_OpenFormFillInfo();
-    const formHandle = this.pdfiumModule.PDFiumExt_InitFormFillEnvironment(
-      ctx.docPtr,
-      formFillInfoPtr
-    );
     const pageCtx = ctx.acquirePage(page.index);
-    this.pdfiumModule.FORM_OnAfterLoadPage(pageCtx.pagePtr, formHandle);
-    const annotationPtr = this.getAnnotationByName(pageCtx.pagePtr, annotation.id);
-    if (!annotationPtr) {
+    try {
+      return pageCtx.withFormHandle((formHandle) => {
+        const annotationPtr = this.getAnnotationByName(pageCtx.pagePtr, annotation.id);
+        if (!annotationPtr) {
+          return PdfTaskHelper.reject({
+            code: PdfErrorCode.NotFound,
+            message: "annotation not found"
+          });
+        }
+        try {
+          if (!this.pdfiumModule.FORM_SetFocusedAnnot(formHandle, annotationPtr)) {
+            return PdfTaskHelper.reject({
+              code: PdfErrorCode.CantFocusAnnot,
+              message: "failed to set focused annotation"
+            });
+          }
+          switch (value.kind) {
+            case "text": {
+              if (!this.pdfiumModule.FORM_SelectAllText(formHandle, pageCtx.pagePtr)) {
+                this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+                return PdfTaskHelper.reject({
+                  code: PdfErrorCode.CantSelectText,
+                  message: "failed to select all text"
+                });
+              }
+              const length = 2 * (value.text.length + 1);
+              const textPtr = this.memoryManager.malloc(length);
+              this.pdfiumModule.pdfium.stringToUTF16(value.text, textPtr, length);
+              this.pdfiumModule.FORM_ReplaceSelection(formHandle, pageCtx.pagePtr, textPtr);
+              this.memoryManager.free(textPtr);
+              break;
+            }
+            case "selection": {
+              if (!this.pdfiumModule.FORM_SetIndexSelected(
+                formHandle,
+                pageCtx.pagePtr,
+                value.index,
+                value.isSelected
+              )) {
+                this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+                return PdfTaskHelper.reject({
+                  code: PdfErrorCode.CantSelectOption,
+                  message: "failed to set index selected"
+                });
+              }
+              break;
+            }
+            case "checked": {
+              const rawChecked = this.pdfiumModule.FPDFAnnot_IsChecked(formHandle, annotationPtr);
+              const currentlyChecked = !!rawChecked;
+              if (currentlyChecked !== value.checked) {
+                const kReturn = 13;
+                if (!this.pdfiumModule.FORM_OnChar(formHandle, pageCtx.pagePtr, kReturn, 0)) {
+                  this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+                  return PdfTaskHelper.reject({
+                    code: PdfErrorCode.CantCheckField,
+                    message: "failed to set field checked"
+                  });
+                }
+              }
+              break;
+            }
+          }
+          this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+          this.pdfiumModule.EPDFAnnot_GenerateFormFieldAP(annotationPtr);
+          return PdfTaskHelper.resolve(true);
+        } finally {
+          this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
+        }
+      });
+    } finally {
       pageCtx.release();
+    }
+  }
+  /**
+   * {@inheritDoc @embedpdf/models!PdfEngine.setFormFieldState}
+   *
+   * @public
+   */
+  setFormFieldState(doc, page, annotation, field) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "SetFormFieldState", doc, annotation, field);
+    this.logger.perf(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      `SetFormFieldState`,
+      "Begin",
+      `${doc.id}-${annotation.id}`
+    );
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "SetFormFieldState", "document is not opened");
       this.logger.perf(
         LOG_SOURCE,
         LOG_CATEGORY,
-        "SetFormFieldValue",
+        `SetFormFieldState`,
         "End",
-        `${doc.id}-${page.index}`
+        `${doc.id}-${annotation.id}`
       );
-      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "annotation not found" });
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
     }
-    if (!this.pdfiumModule.FORM_SetFocusedAnnot(formHandle, annotationPtr)) {
-      this.logger.debug(
-        LOG_SOURCE,
-        LOG_CATEGORY,
-        "SetFormFieldValue",
-        "failed to set focused annotation"
-      );
+    const pageCtx = ctx.acquirePage(page.index);
+    try {
+      return pageCtx.withFormHandle((formHandle) => {
+        const annotationPtr = this.getAnnotationByName(pageCtx.pagePtr, annotation.id);
+        if (!annotationPtr) {
+          return PdfTaskHelper.reject({
+            code: PdfErrorCode.NotFound,
+            message: "annotation not found"
+          });
+        }
+        try {
+          if (!this.pdfiumModule.FORM_SetFocusedAnnot(formHandle, annotationPtr)) {
+            return PdfTaskHelper.reject({
+              code: PdfErrorCode.CantFocusAnnot,
+              message: "failed to set focused annotation"
+            });
+          }
+          switch (field.type) {
+            case PDF_FORM_FIELD_TYPE.TEXTFIELD: {
+              if (!this.pdfiumModule.FORM_SelectAllText(formHandle, pageCtx.pagePtr)) {
+                this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+                return PdfTaskHelper.reject({
+                  code: PdfErrorCode.CantSelectText,
+                  message: "failed to select all text"
+                });
+              }
+              const length = 2 * (field.value.length + 1);
+              const textPtr = this.memoryManager.malloc(length);
+              this.pdfiumModule.pdfium.stringToUTF16(field.value, textPtr, length);
+              this.pdfiumModule.FORM_ReplaceSelection(formHandle, pageCtx.pagePtr, textPtr);
+              this.memoryManager.free(textPtr);
+              break;
+            }
+            case PDF_FORM_FIELD_TYPE.CHECKBOX:
+            case PDF_FORM_FIELD_TYPE.RADIOBUTTON: {
+              const currentlyChecked = !!this.pdfiumModule.FPDFAnnot_IsChecked(
+                formHandle,
+                annotationPtr
+              );
+              const desiredChecked = annotation.exportValue != null && field.value === annotation.exportValue;
+              if (currentlyChecked !== desiredChecked) {
+                const kReturn = 13;
+                if (!this.pdfiumModule.FORM_OnChar(formHandle, pageCtx.pagePtr, kReturn, 0)) {
+                  this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+                  return PdfTaskHelper.reject({
+                    code: PdfErrorCode.CantCheckField,
+                    message: "failed to set field checked"
+                  });
+                }
+              }
+              break;
+            }
+            case PDF_FORM_FIELD_TYPE.COMBOBOX: {
+              const selectedIndex = field.options.findIndex((opt) => opt.isSelected);
+              if (selectedIndex >= 0) {
+                if (!this.pdfiumModule.FORM_SetIndexSelected(
+                  formHandle,
+                  pageCtx.pagePtr,
+                  selectedIndex,
+                  true
+                )) {
+                  this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+                  return PdfTaskHelper.reject({
+                    code: PdfErrorCode.CantSelectOption,
+                    message: "failed to set index selected"
+                  });
+                }
+              }
+              break;
+            }
+            case PDF_FORM_FIELD_TYPE.LISTBOX: {
+              for (let i = 0; i < field.options.length; i++) {
+                if (!this.pdfiumModule.FORM_SetIndexSelected(
+                  formHandle,
+                  pageCtx.pagePtr,
+                  i,
+                  field.options[i].isSelected
+                )) {
+                  this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+                  return PdfTaskHelper.reject({
+                    code: PdfErrorCode.CantSelectOption,
+                    message: "failed to set index selected"
+                  });
+                }
+              }
+              break;
+            }
+            default:
+              break;
+          }
+          this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
+          if (field.type !== PDF_FORM_FIELD_TYPE.CHECKBOX && field.type !== PDF_FORM_FIELD_TYPE.RADIOBUTTON) {
+            this.pdfiumModule.EPDFAnnot_GenerateFormFieldAP(annotationPtr);
+          }
+          this.logger.perf(
+            LOG_SOURCE,
+            LOG_CATEGORY,
+            `SetFormFieldState`,
+            "End",
+            `${doc.id}-${annotation.id}`
+          );
+          return PdfTaskHelper.resolve(true);
+        } finally {
+          this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
+        }
+      });
+    } finally {
+      pageCtx.release();
+    }
+  }
+  renameWidgetField(doc, page, annotation, name) {
+    this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "RenameWidgetField", doc, annotation, name);
+    this.logger.perf(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      `RenameWidgetField`,
+      "Begin",
+      `${doc.id}-${annotation.id}`
+    );
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
       this.logger.perf(
         LOG_SOURCE,
         LOG_CATEGORY,
-        `SetFormFieldValue`,
+        `RenameWidgetField`,
         "End",
         `${doc.id}-${annotation.id}`
       );
-      this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
-      this.pdfiumModule.FORM_OnBeforeClosePage(pageCtx.pagePtr, formHandle);
-      pageCtx.release();
-      this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(formHandle);
-      this.pdfiumModule.PDFiumExt_CloseFormFillInfo(formFillInfoPtr);
       return PdfTaskHelper.reject({
-        code: PdfErrorCode.CantFocusAnnot,
-        message: "failed to set focused annotation"
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
       });
     }
-    switch (value.kind) {
-      case "text":
-        {
-          if (!this.pdfiumModule.FORM_SelectAllText(formHandle, pageCtx.pagePtr)) {
-            this.logger.debug(
-              LOG_SOURCE,
-              LOG_CATEGORY,
-              "SetFormFieldValue",
-              "failed to select all text"
-            );
-            this.logger.perf(
-              LOG_SOURCE,
-              LOG_CATEGORY,
-              `SetFormFieldValue`,
-              "End",
-              `${doc.id}-${annotation.id}`
-            );
-            this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
-            this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
-            this.pdfiumModule.FORM_OnBeforeClosePage(pageCtx.pagePtr, formHandle);
-            pageCtx.release();
-            this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(formHandle);
-            this.pdfiumModule.PDFiumExt_CloseFormFillInfo(formFillInfoPtr);
+    const pageCtx = ctx.acquirePage(page.index);
+    try {
+      return pageCtx.withFormHandle((formHandle) => {
+        const annotationPtr = this.getAnnotationByName(pageCtx.pagePtr, annotation.id);
+        if (!annotationPtr) {
+          return PdfTaskHelper.reject({
+            code: PdfErrorCode.NotFound,
+            message: "annotation not found"
+          });
+        }
+        try {
+          const ok = this.withWString(
+            name,
+            (namePtr) => this.pdfiumModule.EPDFAnnot_SetFormFieldName(formHandle, annotationPtr, namePtr)
+          );
+          if (!ok) {
             return PdfTaskHelper.reject({
-              code: PdfErrorCode.CantSelectText,
-              message: "failed to select all text"
+              code: PdfErrorCode.CantSetAnnotString,
+              message: "failed to rename widget field"
             });
           }
-          const length = 2 * (value.text.length + 1);
-          const textPtr = this.memoryManager.malloc(length);
-          this.pdfiumModule.pdfium.stringToUTF16(value.text, textPtr, length);
-          this.pdfiumModule.FORM_ReplaceSelection(formHandle, pageCtx.pagePtr, textPtr);
-          this.memoryManager.free(textPtr);
+          this.logger.perf(
+            LOG_SOURCE,
+            LOG_CATEGORY,
+            `RenameWidgetField`,
+            "End",
+            `${doc.id}-${annotation.id}`
+          );
+          return PdfTaskHelper.resolve(true);
+        } finally {
+          this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
         }
-        break;
-      case "selection":
-        {
-          if (!this.pdfiumModule.FORM_SetIndexSelected(
-            formHandle,
-            pageCtx.pagePtr,
-            value.index,
-            value.isSelected
-          )) {
-            this.logger.debug(
-              LOG_SOURCE,
-              LOG_CATEGORY,
-              "SetFormFieldValue",
-              "failed to set index selected"
-            );
-            this.logger.perf(
-              LOG_SOURCE,
-              LOG_CATEGORY,
-              `SetFormFieldValue`,
-              "End",
-              `${doc.id}-${annotation.id}`
-            );
-            this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
-            this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
-            this.pdfiumModule.FORM_OnBeforeClosePage(pageCtx.pagePtr, formHandle);
-            pageCtx.release();
-            this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(formHandle);
-            this.pdfiumModule.PDFiumExt_CloseFormFillInfo(formFillInfoPtr);
-            return PdfTaskHelper.reject({
-              code: PdfErrorCode.CantSelectOption,
-              message: "failed to set index selected"
-            });
+      });
+    } finally {
+      pageCtx.release();
+    }
+  }
+  shareWidgetField(doc, sourcePage, sourceAnnotation, targetPage, targetAnnotation) {
+    this.logger.debug(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      "ShareWidgetField",
+      doc,
+      sourceAnnotation,
+      targetAnnotation
+    );
+    this.logger.perf(
+      LOG_SOURCE,
+      LOG_CATEGORY,
+      `ShareWidgetField`,
+      "Begin",
+      `${doc.id}-${sourceAnnotation.id}-${targetAnnotation.id}`
+    );
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      this.logger.perf(
+        LOG_SOURCE,
+        LOG_CATEGORY,
+        `ShareWidgetField`,
+        "End",
+        `${doc.id}-${sourceAnnotation.id}-${targetAnnotation.id}`
+      );
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const sourcePageCtx = ctx.acquirePage(sourcePage.index);
+    const targetPageCtx = targetPage.index === sourcePage.index ? sourcePageCtx : ctx.acquirePage(targetPage.index);
+    try {
+      return sourcePageCtx.withFormHandle((formHandle) => {
+        let targetPageLoaded = false;
+        if (targetPageCtx !== sourcePageCtx) {
+          this.pdfiumModule.FORM_OnAfterLoadPage(targetPageCtx.pagePtr, formHandle);
+          targetPageLoaded = true;
+        }
+        const sourceAnnotationPtr = this.getAnnotationByName(
+          sourcePageCtx.pagePtr,
+          sourceAnnotation.id
+        );
+        const targetAnnotationPtr = this.getAnnotationByName(
+          targetPageCtx.pagePtr,
+          targetAnnotation.id
+        );
+        if (!sourceAnnotationPtr || !targetAnnotationPtr) {
+          if (sourceAnnotationPtr) {
+            this.pdfiumModule.FPDFPage_CloseAnnot(sourceAnnotationPtr);
           }
+          if (targetAnnotationPtr) {
+            this.pdfiumModule.FPDFPage_CloseAnnot(targetAnnotationPtr);
+          }
+          if (targetPageLoaded) {
+            this.pdfiumModule.FORM_OnBeforeClosePage(targetPageCtx.pagePtr, formHandle);
+          }
+          return PdfTaskHelper.reject({
+            code: PdfErrorCode.NotFound,
+            message: "annotation not found"
+          });
         }
-        break;
-      case "checked":
-        {
-          const kReturn = 13;
-          if (!this.pdfiumModule.FORM_OnChar(formHandle, pageCtx.pagePtr, kReturn, 0)) {
-            this.logger.debug(
-              LOG_SOURCE,
-              LOG_CATEGORY,
-              "SetFormFieldValue",
-              "failed to set field checked"
-            );
-            this.logger.perf(
-              LOG_SOURCE,
-              LOG_CATEGORY,
-              `SetFormFieldValue`,
-              "End",
-              `${doc.id}-${annotation.id}`
-            );
-            this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
-            this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
-            this.pdfiumModule.FORM_OnBeforeClosePage(pageCtx.pagePtr, formHandle);
-            pageCtx.release();
-            this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(formHandle);
-            this.pdfiumModule.PDFiumExt_CloseFormFillInfo(formFillInfoPtr);
+        try {
+          const ok = this.pdfiumModule.EPDFAnnot_ShareFormField(
+            formHandle,
+            sourceAnnotationPtr,
+            targetAnnotationPtr
+          );
+          if (!ok) {
             return PdfTaskHelper.reject({
-              code: PdfErrorCode.CantCheckField,
-              message: "failed to set field checked"
+              code: PdfErrorCode.Unknown,
+              message: "failed to share widget field"
             });
           }
+          this.logger.perf(
+            LOG_SOURCE,
+            LOG_CATEGORY,
+            `ShareWidgetField`,
+            "End",
+            `${doc.id}-${sourceAnnotation.id}-${targetAnnotation.id}`
+          );
+          return PdfTaskHelper.resolve(true);
+        } finally {
+          this.pdfiumModule.FPDFPage_CloseAnnot(sourceAnnotationPtr);
+          this.pdfiumModule.FPDFPage_CloseAnnot(targetAnnotationPtr);
+          if (targetPageLoaded) {
+            this.pdfiumModule.FORM_OnBeforeClosePage(targetPageCtx.pagePtr, formHandle);
+          }
         }
-        break;
+      });
+    } finally {
+      sourcePageCtx.release();
+      if (targetPageCtx !== sourcePageCtx) {
+        targetPageCtx.release();
+      }
     }
-    this.pdfiumModule.FORM_ForceToKillFocus(formHandle);
-    this.pdfiumModule.FPDFPage_CloseAnnot(annotationPtr);
-    this.pdfiumModule.FORM_OnBeforeClosePage(pageCtx.pagePtr, formHandle);
-    pageCtx.release();
-    this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(formHandle);
-    this.pdfiumModule.PDFiumExt_CloseFormFillInfo(formFillInfoPtr);
-    return PdfTaskHelper.resolve(true);
   }
   /**
    * {@inheritDoc @embedpdf/models!PdfEngine.flattenPage}
@@ -2943,7 +3433,7 @@ class PdfiumNative {
     }
     if (!this.setAnnotationDefaultAppearance(
       annotationPtr,
-      annotation.fontFamily,
+      annotation.fontFamily === PdfStandardFont.Unknown ? PdfStandardFont.Helvetica : annotation.fontFamily,
       annotation.fontSize,
       annotation.fontColor
     )) {
@@ -2963,6 +3453,184 @@ class PdfiumNative {
     this.setRectangleDifferences(annotationPtr, annotation.rectangleDifferences);
     return this.applyBaseAnnotationProperties(doc, page, pagePtr, annotationPtr, annotation);
   }
+  addTextFieldContent(formHandle, annotationPtr, annotation) {
+    if (!this.setAnnotationDefaultAppearance(
+      annotationPtr,
+      annotation.fontFamily,
+      annotation.fontSize,
+      annotation.fontColor
+    )) {
+      return false;
+    }
+    if (!this.setBorderStyle(
+      annotationPtr,
+      PdfAnnotationBorderStyle.SOLID,
+      annotation.strokeWidth ?? 1
+    )) {
+      return false;
+    }
+    if (annotation.strokeColor && annotation.strokeColor !== "transparent") {
+      this.setMKColor(annotationPtr, 0, annotation.strokeColor);
+    } else {
+      this.clearMKColor(annotationPtr, 0);
+    }
+    if (annotation.color && annotation.color !== "transparent") {
+      this.setMKColor(annotationPtr, 1, annotation.color);
+    } else {
+      this.clearMKColor(annotationPtr, 1);
+    }
+    const userFlags = annotation.field.flag ?? PDF_FORM_FIELD_FLAG.NONE;
+    this.pdfiumModule.FPDFAnnot_SetFormFieldFlags(formHandle, annotationPtr, userFlags);
+    if (annotation.field.name) {
+      this.withWString(
+        annotation.field.name,
+        (namePtr) => this.pdfiumModule.EPDFAnnot_SetFormFieldName(formHandle, annotationPtr, namePtr)
+      );
+    }
+    this.withWString(
+      annotation.field.value ?? "",
+      (valuePtr) => this.pdfiumModule.EPDFAnnot_SetFormFieldValue(formHandle, annotationPtr, valuePtr)
+    );
+    const textField = annotation.field;
+    if (textField.maxLen != null && textField.maxLen > 0) {
+      this.pdfiumModule.EPDFAnnot_SetNumberValue(annotationPtr, "MaxLen", textField.maxLen);
+    }
+    return true;
+  }
+  addToggleFieldContent(formHandle, annotationPtr, annotation) {
+    if (!this.setBorderStyle(
+      annotationPtr,
+      PdfAnnotationBorderStyle.SOLID,
+      annotation.strokeWidth ?? 1
+    )) {
+      return false;
+    }
+    if (annotation.strokeColor && annotation.strokeColor !== "transparent") {
+      this.setMKColor(annotationPtr, 0, annotation.strokeColor);
+    } else {
+      this.clearMKColor(annotationPtr, 0);
+    }
+    if (annotation.color && annotation.color !== "transparent") {
+      this.setMKColor(annotationPtr, 1, annotation.color);
+    } else {
+      this.clearMKColor(annotationPtr, 1);
+    }
+    let finalFlags = annotation.field.flag ?? PDF_FORM_FIELD_FLAG.NONE;
+    if (annotation.field.type === PDF_FORM_FIELD_TYPE.RADIOBUTTON) {
+      finalFlags |= PDF_FORM_FIELD_FLAG.BUTTON_RADIO | PDF_FORM_FIELD_FLAG.BUTTON_NOTOGGLETOOFF;
+    }
+    this.pdfiumModule.FPDFAnnot_SetFormFieldFlags(formHandle, annotationPtr, finalFlags);
+    if (annotation.field.name) {
+      this.withWString(
+        annotation.field.name,
+        (namePtr) => this.pdfiumModule.EPDFAnnot_SetFormFieldName(formHandle, annotationPtr, namePtr)
+      );
+    }
+    return true;
+  }
+  addChoiceFieldContent(formHandle, annotationPtr, annotation) {
+    if (!this.setAnnotationDefaultAppearance(
+      annotationPtr,
+      annotation.fontFamily,
+      annotation.fontSize,
+      annotation.fontColor
+    )) {
+      return false;
+    }
+    if (!this.setBorderStyle(
+      annotationPtr,
+      PdfAnnotationBorderStyle.SOLID,
+      annotation.strokeWidth ?? 1
+    )) {
+      return false;
+    }
+    if (annotation.strokeColor && annotation.strokeColor !== "transparent") {
+      this.setMKColor(annotationPtr, 0, annotation.strokeColor);
+    } else {
+      this.clearMKColor(annotationPtr, 0);
+    }
+    if (annotation.color && annotation.color !== "transparent") {
+      this.setMKColor(annotationPtr, 1, annotation.color);
+    } else {
+      this.clearMKColor(annotationPtr, 1);
+    }
+    let choiceFlags = annotation.field.flag ?? PDF_FORM_FIELD_FLAG.NONE;
+    if (annotation.field.type === PDF_FORM_FIELD_TYPE.COMBOBOX) {
+      choiceFlags |= 1 << 17;
+    }
+    this.pdfiumModule.FPDFAnnot_SetFormFieldFlags(formHandle, annotationPtr, choiceFlags);
+    if (annotation.field.name) {
+      this.withWString(
+        annotation.field.name,
+        (namePtr) => this.pdfiumModule.EPDFAnnot_SetFormFieldName(formHandle, annotationPtr, namePtr)
+      );
+    }
+    const field = annotation.field;
+    const options = field.options ?? [];
+    if (options.length > 0) {
+      const ptrSize = 4;
+      const arrayPtr = this.memoryManager.malloc(options.length * ptrSize);
+      const labelPtrs = [];
+      try {
+        for (let i = 0; i < options.length; i++) {
+          const label = options[i].label;
+          const byteLen = (label.length + 1) * 2;
+          const labelPtr = this.memoryManager.malloc(byteLen);
+          this.pdfiumModule.pdfium.stringToUTF16(label, labelPtr, byteLen);
+          labelPtrs.push(labelPtr);
+          this.pdfiumModule.pdfium.setValue(arrayPtr + i * ptrSize, labelPtr, "*");
+        }
+        this.pdfiumModule.EPDFAnnot_SetFormFieldOptions(
+          formHandle,
+          annotationPtr,
+          arrayPtr,
+          options.length
+        );
+      } finally {
+        for (const ptr of labelPtrs) {
+          this.memoryManager.free(WasmPointer(ptr));
+        }
+        this.memoryManager.free(arrayPtr);
+      }
+    }
+    const selectedOption = options.find((opt) => opt.isSelected);
+    const value = (selectedOption == null ? void 0 : selectedOption.label) ?? annotation.field.value ?? "";
+    this.withWString(
+      value,
+      (valuePtr) => this.pdfiumModule.EPDFAnnot_SetFormFieldValue(formHandle, annotationPtr, valuePtr)
+    );
+    return true;
+  }
+  setMKColor(annotationPtr, mkType, webColor) {
+    const { red, green, blue } = webColorToPdfColor(webColor);
+    return this.pdfiumModule.EPDFAnnot_SetMKColor(
+      annotationPtr,
+      mkType,
+      red & 255,
+      green & 255,
+      blue & 255
+    );
+  }
+  clearMKColor(annotationPtr, mkType) {
+    return this.pdfiumModule.EPDFAnnot_ClearMKColor(annotationPtr, mkType);
+  }
+  getMKColor(annotationPtr, mkType) {
+    const rPtr = this.memoryManager.malloc(4);
+    const gPtr = this.memoryManager.malloc(4);
+    const bPtr = this.memoryManager.malloc(4);
+    try {
+      const ok = this.pdfiumModule.EPDFAnnot_GetMKColor(annotationPtr, mkType, rPtr, gPtr, bPtr);
+      if (!ok) return void 0;
+      const r = this.pdfiumModule.pdfium.getValue(rPtr, "i32") & 255;
+      const g = this.pdfiumModule.pdfium.getValue(gPtr, "i32") & 255;
+      const b = this.pdfiumModule.pdfium.getValue(bPtr, "i32") & 255;
+      return pdfColorToWebColor({ red: r, green: g, blue: b });
+    } finally {
+      this.memoryManager.free(bPtr);
+      this.memoryManager.free(gPtr);
+      this.memoryManager.free(rPtr);
+    }
+  }
   /**
    * Set the rect of specified annotation
    * @param page - page info that the annotation is belonged to
@@ -3260,9 +3928,10 @@ class PdfiumNative {
       return false;
     }
     if (annotation.fontFamily !== void 0 || annotation.fontSize !== void 0) {
+      const font = annotation.fontFamily == null || annotation.fontFamily === PdfStandardFont.Unknown ? PdfStandardFont.Helvetica : annotation.fontFamily;
       if (!this.setAnnotationDefaultAppearance(
         annotationPtr,
-        annotation.fontFamily ?? PdfStandardFont.Helvetica,
+        font,
         annotation.fontSize ?? 12,
         annotation.fontColor ?? "#000000"
       )) {
@@ -4254,18 +4923,45 @@ class PdfiumNative {
    */
   readPageAnnotations(doc, ctx, page) {
     return ctx.borrowPage(page.index, (pageCtx) => {
-      const annotationCount = this.pdfiumModule.FPDFPage_GetAnnotCount(pageCtx.pagePtr);
-      const annotations = [];
-      for (let i = 0; i < annotationCount; i++) {
-        pageCtx.withAnnotation(i, (annotPtr) => {
-          const anno = this.readPageAnnotation(doc, ctx.docPtr, page, annotPtr, pageCtx);
-          if (anno) annotations.push(anno);
-        });
-      }
-      return annotations;
+      return pageCtx.withFormHandle((formHandle) => {
+        const annotationCount = this.pdfiumModule.FPDFPage_GetAnnotCount(pageCtx.pagePtr);
+        const annotations = [];
+        for (let i = 0; i < annotationCount; i++) {
+          pageCtx.withAnnotation(i, (annotPtr) => {
+            const anno = this.readPageAnnotation(doc, ctx.docPtr, page, annotPtr, formHandle);
+            if (anno) annotations.push(anno);
+          });
+        }
+        return annotations;
+      });
     });
   }
   /**
+   *
+   *
+   * @param ctx - document context
+   * @param page - page info
+   * @returns form fields on the pdf page
+   *
+   * @private
+   */
+  readPageAnnoWidgets(doc, ctx, page) {
+    return ctx.borrowPage(page.index, (pageCtx) => {
+      return pageCtx.withFormHandle((formHandle) => {
+        const annotationCount = this.pdfiumModule.FPDFPage_GetAnnotCount(pageCtx.pagePtr);
+        const annotations = [];
+        for (let i = 0; i < annotationCount; i++) {
+          pageCtx.withAnnotation(i, (annotPtr) => {
+            const anno = this.readPageAnnoWidget(doc, page, annotPtr, formHandle);
+            if (anno) annotations.push(anno);
+          });
+        }
+        return annotations;
+      });
+    });
+  }
+  /**
+   * Read page annotations
    * Read page annotations without loading the page (raw approach)
    *
    * @param doc - pdf document object
@@ -4275,7 +4971,7 @@ class PdfiumNative {
    *
    * @private
    */
-  readPageAnnotationsRaw(doc, ctx, page) {
+  readPageAnnotationsRaw(doc, ctx, page, formHandle) {
     const count = this.pdfiumModule.EPDFPage_GetAnnotCountRaw(ctx.docPtr, page.index);
     if (count <= 0) return [];
     const out = [];
@@ -4283,7 +4979,7 @@ class PdfiumNative {
       const annotPtr = this.pdfiumModule.EPDFPage_GetAnnotRaw(ctx.docPtr, page.index, i);
       if (!annotPtr) continue;
       try {
-        const anno = this.readPageAnnotation(doc, ctx.docPtr, page, annotPtr);
+        const anno = this.readPageAnnotation(doc, ctx.docPtr, page, annotPtr, formHandle);
         if (anno) out.push(anno);
       } finally {
         this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
@@ -4292,6 +4988,29 @@ class PdfiumNative {
     return out;
   }
   /**
+   * Read page form field
+   *
+   * @param ctx - document context
+   * @param page - page info
+   * @param annotationPtr - pointer to pdf annotation
+   * @param pageCtx - page context
+   * @returns form field
+   *
+   * @private
+   */
+  readPageAnnoWidget(doc, page, annotationPtr, formHandle) {
+    let index = this.getAnnotString(annotationPtr, "NM");
+    if (!index || !isUuidV4(index)) {
+      index = uuidV4();
+      this.setAnnotString(annotationPtr, "NM", index);
+    }
+    const subType = this.pdfiumModule.FPDFAnnot_GetSubtype(
+      annotationPtr
+    );
+    if (subType !== PdfAnnotationSubtype.WIDGET) return;
+    return this.readPdfWidgetAnno(doc, page, annotationPtr, formHandle, index);
+  }
+  /*
    * Get page annotations (public API, returns Task)
    *
    * @param doc - pdf document
@@ -4316,22 +5035,29 @@ class PdfiumNative {
         message: "document does not open"
       });
     }
-    const out = this.readPageAnnotationsRaw(doc, ctx, page);
-    this.logger.perf(
-      LOG_SOURCE,
-      LOG_CATEGORY,
-      `GetPageAnnotationsRaw`,
-      "End",
-      `${doc.id}-${page.index}`
-    );
-    this.logger.debug(
-      LOG_SOURCE,
-      LOG_CATEGORY,
-      "getPageAnnotationsRaw",
-      `${doc.id}-${page.index}`,
-      out
-    );
-    return PdfTaskHelper.resolve(out);
+    const formInfoPtr = this.pdfiumModule.PDFiumExt_OpenFormFillInfo();
+    const formHandle = this.pdfiumModule.PDFiumExt_InitFormFillEnvironment(ctx.docPtr, formInfoPtr);
+    try {
+      const out = this.readPageAnnotationsRaw(doc, ctx, page, formHandle);
+      this.logger.perf(
+        LOG_SOURCE,
+        LOG_CATEGORY,
+        `GetPageAnnotationsRaw`,
+        "End",
+        `${doc.id}-${page.index}`
+      );
+      this.logger.debug(
+        LOG_SOURCE,
+        LOG_CATEGORY,
+        "getPageAnnotationsRaw",
+        `${doc.id}-${page.index}`,
+        out
+      );
+      return PdfTaskHelper.resolve(out);
+    } finally {
+      this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(formHandle);
+      this.pdfiumModule.PDFiumExt_CloseFormFillInfo(formInfoPtr);
+    }
   }
   /**
    * Read pdf annotation from pdf document
@@ -4340,12 +5066,12 @@ class PdfiumNative {
    * @param docPtr - pointer to pdf document
    * @param page - page info
    * @param annotationPtr - pointer to pdf annotation
-   * @param pageCtx - page context
+   * @param formHandle - optional form fill handle for widget annotations
    * @returns pdf annotation
    *
    * @private
    */
-  readPageAnnotation(doc, docPtr, page, annotationPtr, pageCtx) {
+  readPageAnnotation(doc, docPtr, page, annotationPtr, formHandle) {
     let index = this.getAnnotString(annotationPtr, "NM");
     if (!index || !isUuidV4(index)) {
       index = uuidV4();
@@ -4372,9 +5098,12 @@ class PdfiumNative {
         }
         break;
       case PdfAnnotationSubtype.WIDGET:
-        if (pageCtx) {
-          return this.readPdfWidgetAnno(doc, page, annotationPtr, pageCtx.getFormHandle(), index);
+        {
+          if (formHandle !== void 0) {
+            return this.readPdfWidgetAnno(doc, page, annotationPtr, formHandle, index);
+          }
         }
+        break;
       case PdfAnnotationSubtype.FILEATTACHMENT:
         {
           annotation = this.readPdfFileAttachmentAnno(doc, page, annotationPtr, index);
@@ -4696,10 +5425,10 @@ class PdfiumNative {
    * @returns true on success
    */
   setAnnotUnrotatedRect(doc, page, annotPtr, rect) {
-    const x0d = Math.floor(rect.origin.x);
-    const y0d = Math.floor(rect.origin.y);
-    const x1d = Math.floor(rect.origin.x + rect.size.width);
-    const y1d = Math.floor(rect.origin.y + rect.size.height);
+    const x0d = rect.origin.x;
+    const y0d = rect.origin.y;
+    const x1d = rect.origin.x + rect.size.width;
+    const y1d = rect.origin.y + rect.size.height;
     const TL = this.convertDevicePointToPagePoint(doc, page, { x: x0d, y: y0d });
     const TR = this.convertDevicePointToPagePoint(doc, page, { x: x1d, y: y0d });
     const BR = this.convertDevicePointToPagePoint(doc, page, { x: x1d, y: y1d });
@@ -4869,11 +5598,10 @@ class PdfiumNative {
    * @returns `true` on success
    */
   setAnnotationDefaultAppearance(annotationPtr, font, fontSize, color) {
-    const resolvedFont = font === PdfStandardFont.Unknown ? PdfStandardFont.Helvetica : font;
     const { red, green, blue } = webColorToPdfColor(color);
     return !!this.pdfiumModule.EPDFAnnot_SetDefaultAppearance(
       annotationPtr,
-      resolvedFont,
+      font,
       fontSize,
       red & 255,
       green & 255,
@@ -5724,14 +6452,27 @@ class PdfiumNative {
    */
   readPdfWidgetAnno(doc, page, annotationPtr, formHandle, index) {
     const pageRect = this.readPageAnnoRect(annotationPtr);
+    this.getAnnotationFlags(annotationPtr);
+    const da = this.getAnnotationDefaultAppearance(annotationPtr);
     const rect = this.convertPageRectToDeviceRect(doc, page, pageRect);
     const field = this.readPdfWidgetAnnoField(formHandle, annotationPtr);
+    const exportValue = this.readButtonExportValue(annotationPtr);
+    const strokeColor = this.getMKColor(annotationPtr, 0);
+    const color = this.getMKColor(annotationPtr, 1);
+    const { width: strokeWidth } = this.getBorderStyle(annotationPtr);
     return {
       pageIndex: page.index,
       id: index,
       type: PdfAnnotationSubtype.WIDGET,
+      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",
       rect,
       field,
+      ...exportValue !== void 0 && { exportValue },
+      strokeWidth,
+      strokeColor: strokeColor ?? "transparent",
+      color: color ?? "transparent",
       ...this.readBaseAnnotationProperties(doc, page, annotationPtr)
     };
   }
@@ -6717,6 +7458,16 @@ class PdfiumNative {
     this.memoryManager.free(ptr);
     return value || void 0;
   }
+  readButtonExportValue(annotationPtr) {
+    const len = this.pdfiumModule.EPDFAnnot_GetButtonExportValue(annotationPtr, 0, 0);
+    if (len === 0) return;
+    const bytes = (len + 1) * 2;
+    const ptr = this.memoryManager.malloc(bytes);
+    this.pdfiumModule.EPDFAnnot_GetButtonExportValue(annotationPtr, ptr, bytes);
+    const value = this.pdfiumModule.pdfium.UTF16ToString(ptr);
+    this.memoryManager.free(ptr);
+    return value || void 0;
+  }
   /**
    * Get a string value (`/T`, `/M`, `/State`, …) from an attachment.
    *
@@ -7017,7 +7768,7 @@ class PdfiumNative {
     const value = readString(
       this.pdfiumModule.pdfium,
       (buffer, bufferLength) => {
-        return this.pdfiumModule.FPDFAnnot_GetFormFieldValue(
+        return this.pdfiumModule.EPDFAnnot_GetFormFieldRawValue(
           formHandle,
           annotationPtr,
           buffer,
@@ -7026,47 +7777,69 @@ class PdfiumNative {
       },
       this.pdfiumModule.pdfium.UTF16ToString
     );
-    const options = [];
-    if (type === PDF_FORM_FIELD_TYPE.COMBOBOX || type === PDF_FORM_FIELD_TYPE.LISTBOX) {
-      const count = this.pdfiumModule.FPDFAnnot_GetOptionCount(formHandle, annotationPtr);
-      for (let i = 0; i < count; i++) {
-        const label = readString(
-          this.pdfiumModule.pdfium,
-          (buffer, bufferLength) => {
-            return this.pdfiumModule.FPDFAnnot_GetOptionLabel(
-              formHandle,
-              annotationPtr,
-              i,
-              buffer,
-              bufferLength
-            );
-          },
-          this.pdfiumModule.pdfium.UTF16ToString
-        );
-        const isSelected = this.pdfiumModule.FPDFAnnot_IsOptionSelected(
-          formHandle,
-          annotationPtr,
-          i
-        );
-        options.push({
-          label,
-          isSelected
-        });
-      }
-    }
-    let isChecked = false;
-    if (type === PDF_FORM_FIELD_TYPE.CHECKBOX || type === PDF_FORM_FIELD_TYPE.RADIOBUTTON) {
-      isChecked = this.pdfiumModule.FPDFAnnot_IsChecked(formHandle, annotationPtr);
-    }
-    return {
+    const fieldObjectId = this.pdfiumModule.EPDFAnnot_GetFormFieldObjectNumber(
+      formHandle,
+      annotationPtr
+    );
+    const base = {
       flag,
-      type,
       name,
       alternateName,
       value,
-      isChecked,
-      options
+      fieldObjectId: fieldObjectId > 0 ? fieldObjectId : void 0
     };
+    switch (type) {
+      case PDF_FORM_FIELD_TYPE.TEXTFIELD: {
+        let maxLen;
+        const floatPtr = this.memoryManager.malloc(4);
+        const ok = this.pdfiumModule.FPDFAnnot_GetNumberValue(annotationPtr, "MaxLen", floatPtr);
+        if (ok) {
+          maxLen = this.pdfiumModule.pdfium.getValue(floatPtr, "float");
+        }
+        this.memoryManager.free(floatPtr);
+        return { ...base, type, maxLen };
+      }
+      case PDF_FORM_FIELD_TYPE.CHECKBOX:
+        return { ...base, type };
+      case PDF_FORM_FIELD_TYPE.RADIOBUTTON:
+        return {
+          ...base,
+          type,
+          options: this.readWidgetOptions(formHandle, annotationPtr)
+        };
+      case PDF_FORM_FIELD_TYPE.COMBOBOX:
+        return { ...base, type, options: this.readWidgetOptions(formHandle, annotationPtr) };
+      case PDF_FORM_FIELD_TYPE.LISTBOX:
+        return { ...base, type, options: this.readWidgetOptions(formHandle, annotationPtr) };
+      case PDF_FORM_FIELD_TYPE.PUSHBUTTON:
+        return { ...base, type };
+      case PDF_FORM_FIELD_TYPE.SIGNATURE:
+        return { ...base, type };
+      default:
+        return { ...base, type };
+    }
+  }
+  readWidgetOptions(formHandle, annotationPtr) {
+    const options = [];
+    const count = this.pdfiumModule.FPDFAnnot_GetOptionCount(formHandle, annotationPtr);
+    for (let i = 0; i < count; i++) {
+      const label = readString(
+        this.pdfiumModule.pdfium,
+        (buffer, bufferLength) => {
+          return this.pdfiumModule.FPDFAnnot_GetOptionLabel(
+            formHandle,
+            annotationPtr,
+            i,
+            buffer,
+            bufferLength
+          );
+        },
+        this.pdfiumModule.pdfium.UTF16ToString
+      );
+      const isSelected = this.pdfiumModule.FPDFAnnot_IsOptionSelected(formHandle, annotationPtr, i);
+      options.push({ label, isSelected });
+    }
+    return options;
   }
   /**
    * {@inheritDoc @embedpdf/models!PdfEngine.renderAnnotation}
@@ -7124,11 +7897,30 @@ class PdfiumNative {
       pageCtx.release();
       return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "annotation not found" });
     }
+    let hasAP = !!this.pdfiumModule.EPDFAnnot_HasAppearanceStream(annotPtr, mode);
+    if (!hasAP && annotation.type === PdfAnnotationSubtype.WIDGET) {
+      if (!this.pdfiumModule.FPDFAnnot_HasKey(annotPtr, "AP")) {
+        this.pdfiumModule.EPDFAnnot_GenerateFormFieldAP(annotPtr);
+        hasAP = !!this.pdfiumModule.EPDFAnnot_HasAppearanceStream(annotPtr, mode);
+      }
+    }
+    if (!hasAP) {
+      this.pdfiumModule.FPDFPage_CloseAnnot(annotPtr);
+      pageCtx.release();
+      this.logger.perf(
+        LOG_SOURCE,
+        LOG_CATEGORY,
+        `RenderPageAnnotation`,
+        "End",
+        `${doc.id}-${page.index}-${annotation.id}`
+      );
+      task.resolve({ data: new Uint8ClampedArray(4), width: 1, height: 1 });
+      return task;
+    }
     const finalScale = Math.max(0.01, scaleFactor * dpr);
     const unrotated = !!(options == null ? void 0 : options.unrotated) && !!annotation.unrotatedRect;
     const renderRect = unrotated ? annotation.unrotatedRect : annotation.rect;
-    const rect = toIntRect(renderRect);
-    const devRect = toIntRect(transformRect(page.size, rect, rotation, finalScale));
+    const devRect = toIntRect(transformRect(page.size, renderRect, rotation, finalScale));
     const wDev = Math.max(1, devRect.size.width);
     const hDev = Math.max(1, devRect.size.height);
     const stride = wDev * 4;
@@ -7142,13 +7934,7 @@ class PdfiumNative {
       stride
     );
     this.pdfiumModule.FPDFBitmap_FillRect(bitmapPtr, 0, 0, wDev, hDev, 0);
-    const M = buildUserToDeviceMatrix(
-      rect,
-      // {origin:{L,B}, size:{W,H}}
-      rotation,
-      wDev,
-      hDev
-    );
+    const M = buildUserToDeviceMatrix(renderRect, rotation, wDev, hDev);
     const mPtr = this.memoryManager.malloc(6 * 4);
     const mView = new Float32Array(this.pdfiumModule.pdfium.HEAPF32.buffer, mPtr, 6);
     mView.set([M.a, M.b, M.c, M.d, M.e, M.f]);
@@ -7299,10 +8085,20 @@ class PdfiumNative {
    * @private
    */
   renderSingleAnnotAppearance(doc, page, pageCtx, annotPtr, mode, rotation, finalScale) {
+    if (!this.pdfiumModule.EPDFAnnot_HasAppearanceStream(annotPtr, mode)) {
+      const subtype = this.pdfiumModule.FPDFAnnot_GetSubtype(annotPtr);
+      if (subtype === PdfAnnotationSubtype.WIDGET && !this.pdfiumModule.FPDFAnnot_HasKey(annotPtr, "AP")) {
+        this.pdfiumModule.EPDFAnnot_GenerateFormFieldAP(annotPtr);
+        if (!this.pdfiumModule.EPDFAnnot_HasAppearanceStream(annotPtr, mode)) {
+          return null;
+        }
+      } else {
+        return null;
+      }
+    }
     const pageRect = this.readPageAnnoRect(annotPtr);
     const annotRect = this.convertPageRectToDeviceRect(doc, page, pageRect);
-    const rect = toIntRect(annotRect);
-    const devRect = toIntRect(transformRect(page.size, rect, rotation, finalScale));
+    const devRect = toIntRect(transformRect(page.size, annotRect, rotation, finalScale));
     const wDev = Math.max(1, devRect.size.width);
     const hDev = Math.max(1, devRect.size.height);
     const stride = wDev * 4;
@@ -7316,7 +8112,7 @@ class PdfiumNative {
       stride
     );
     this.pdfiumModule.FPDFBitmap_FillRect(bitmapPtr, 0, 0, wDev, hDev, 0);
-    const M = buildUserToDeviceMatrix(rect, rotation, wDev, hDev);
+    const M = buildUserToDeviceMatrix(annotRect, rotation, wDev, hDev);
     const mPtr = this.memoryManager.malloc(6 * 4);
     const mView = new Float32Array(this.pdfiumModule.pdfium.HEAPF32.buffer, mPtr, 6);
     mView.set([M.a, M.b, M.c, M.d, M.e, M.f]);
@@ -7370,7 +8166,6 @@ class PdfiumNative {
     const bytes = stride * hDev;
     const pageCtx = ctx.acquirePage(page.index);
     const shouldRenderForms = (options == null ? void 0 : options.withForms) ?? false;
-    const formHandle = shouldRenderForms ? pageCtx.getFormHandle() : void 0;
     const heapPtr = this.memoryManager.malloc(bytes);
     const bitmapPtr = this.pdfiumModule.FPDFBitmap_CreateEx(
       wDev,
@@ -7397,20 +8192,22 @@ class PdfiumNative {
         clipPtr,
         flags
       );
-      if (formHandle !== void 0) {
-        const formParams = computeFormDrawParams(M, rect, page.size, rotation);
-        const { startX, startY, formsWidth, formsHeight, scaleX, scaleY } = formParams;
-        this.pdfiumModule.FPDF_FFLDraw(
-          formHandle,
-          bitmapPtr,
-          pageCtx.pagePtr,
-          startX,
-          startY,
-          formsWidth,
-          formsHeight,
-          rotation,
-          flags
-        );
+      if (shouldRenderForms) {
+        pageCtx.withFormHandle((formHandle) => {
+          const formParams = computeFormDrawParams(M, rect, page.size, rotation);
+          const { startX, startY, formsWidth, formsHeight } = formParams;
+          this.pdfiumModule.FPDF_FFLDraw(
+            formHandle,
+            bitmapPtr,
+            pageCtx.pagePtr,
+            startX,
+            startY,
+            formsWidth,
+            formsHeight,
+            rotation,
+            flags
+          );
+        });
       }
     } finally {
       pageCtx.release();
@@ -7988,10 +8785,10 @@ class PdfiumNative {
    * @private
    */
   setPageAnnoRect(doc, page, annotPtr, rect) {
-    const x0d = Math.floor(rect.origin.x);
-    const y0d = Math.floor(rect.origin.y);
-    const x1d = Math.floor(rect.origin.x + rect.size.width);
-    const y1d = Math.floor(rect.origin.y + rect.size.height);
+    const x0d = rect.origin.x;
+    const y0d = rect.origin.y;
+    const x1d = rect.origin.x + rect.size.width;
+    const y1d = rect.origin.y + rect.size.height;
     const TL = this.convertDevicePointToPagePoint(doc, page, { x: x0d, y: y0d });
     const TR = this.convertDevicePointToPagePoint(doc, page, { x: x1d, y: y0d });
     const BR = this.convertDevicePointToPagePoint(doc, page, { x: x1d, y: y1d });
@@ -8134,16 +8931,26 @@ class PdfiumNative {
       }
       const results = {};
       const total = pages.length;
-      for (let i = 0; i < pages.length; i++) {
-        const page = pages[i];
-        const annotations = this.readPageAnnotationsRaw(doc, ctx, page);
-        results[page.index] = annotations;
-        task.progress({
-          pageIndex: page.index,
-          result: annotations,
-          completed: i + 1,
-          total
-        });
+      const formInfoPtr = this.pdfiumModule.PDFiumExt_OpenFormFillInfo();
+      const formHandle = this.pdfiumModule.PDFiumExt_InitFormFillEnvironment(
+        ctx.docPtr,
+        formInfoPtr
+      );
+      try {
+        for (let i = 0; i < pages.length; i++) {
+          const page = pages[i];
+          const annotations = this.readPageAnnotationsRaw(doc, ctx, page, formHandle);
+          results[page.index] = annotations;
+          task.progress({
+            pageIndex: page.index,
+            result: annotations,
+            completed: i + 1,
+            total
+          });
+        }
+      } finally {
+        this.pdfiumModule.PDFiumExt_ExitFormFillEnvironment(formHandle);
+        this.pdfiumModule.PDFiumExt_CloseFormFillInfo(formInfoPtr);
       }
       this.logger.perf(LOG_SOURCE, LOG_CATEGORY, "GetAnnotationsBatch", "End", doc.id);
       task.resolve(results);
@@ -8559,4 +9366,4 @@ export {
   isValidCustomKey as i,
   readArrayBuffer as r
 };
-//# sourceMappingURL=direct-engine-D-Jf9yyY.js.map
+//# sourceMappingURL=direct-engine-4LZYs06h.js.map