@chialab/pdfjs-lib 1.0.0-alpha.29 → 1.0.0-alpha.30

package/dist/node/index.js

@@ -1,12 +1,15 @@
 import {
   ColorConverters,
+  FontInfo,
   MessageHandler,
   MurmurHash3_64,
   convertBlackAndWhiteToRGBA,
   wrapReason
-} from "./chunk-GWGW2EKY.js";
+} from "./chunk-4Y7OZIIX.js";
 import {
   BaseStandardFontDataFactory,
+  CSSConstants,
+  ColorScheme,
   DOMCMapReaderFactory,
   DOMCanvasFactory,
   DOMFilterFactory,
@@ -25,10 +28,14 @@ import {
   SVG_NS,
   StatTimer,
   SupportedImageMimeTypes,
+  XfaLayer,
+  XfaText,
+  applyOpacity,
   canvasToData,
   colorToRgb,
   deprecated,
   fetchData,
+  findContrastColor,
   getColorValues,
   getCurrentTransform,
   getCurrentTransformInverse,
@@ -42,11 +49,12 @@ import {
   makeSerializable,
   noContextMenu,
   parseRgbaColor,
+  renderRichText,
   rgbToHex,
   setLayerDimensions,
   stopEvent,
   toDataUrl
-} from "./chunk-D4U3W2CD.js";
+} from "./chunk-O74KGUUC.js";
 import {
   AbortException,
   AnnotationBorderStyleType,
@@ -89,7 +97,7 @@ import {
   unreachable,
   updateUrlHash,
   warn
-} from "./chunk-FHASHZBJ.js";
+} from "./chunk-T2JWSGAF.js";
 import {
   __commonJS,
   __privateAdd,
@@ -12368,7 +12376,7 @@ var require_opentype = __commonJS({
 });
 
 // src/pdf.js/src/display/editor/toolbar.js
-var _toolbar, _colorPicker, _editor, _buttons, _altText, _comment, _signatureDescriptionButton, _l10nRemove, _EditorToolbar_static, pointerDown_fn, _EditorToolbar_instances, focusIn_fn, focusOut_fn, addListenersToElement_fn, divider_get;
+var _toolbar, _colorPicker, _editor, _buttons, _altText, _comment, _commentButtonDivider, _signatureDescriptionButton, _l10nRemove, _EditorToolbar_static, pointerDown_fn, _EditorToolbar_instances, focusIn_fn, focusOut_fn, addListenersToElement_fn, divider_get;
 var _EditorToolbar = class _EditorToolbar {
   constructor(editor) {
     __privateAdd(this, _EditorToolbar_instances);
@@ -12378,6 +12386,7 @@ var _EditorToolbar = class _EditorToolbar {
     __privateAdd(this, _buttons, null);
     __privateAdd(this, _altText, null);
     __privateAdd(this, _comment, null);
+    __privateAdd(this, _commentButtonDivider, null);
     __privateAdd(this, _signatureDescriptionButton, null);
     __privateSet(this, _editor, editor);
     __privateGet(_EditorToolbar, _l10nRemove) || __privateSet(_EditorToolbar, _l10nRemove, Object.freeze({
@@ -12446,16 +12455,22 @@ var _EditorToolbar = class _EditorToolbar {
     __privateGet(this, _buttons).append(button, __privateGet(this, _EditorToolbar_instances, divider_get));
     __privateSet(this, _altText, altText);
   }
-  addComment(comment) {
+  addComment(comment, beforeElement = null) {
     if (__privateGet(this, _comment)) {
       return;
     }
-    const button = comment.render();
+    const button = comment.renderForToolbar();
     if (!button) {
       return;
     }
     __privateMethod(this, _EditorToolbar_instances, addListenersToElement_fn).call(this, button);
-    __privateGet(this, _buttons).append(button, __privateGet(this, _EditorToolbar_instances, divider_get));
+    const divider = __privateSet(this, _commentButtonDivider, __privateGet(this, _EditorToolbar_instances, divider_get));
+    if (!beforeElement) {
+      __privateGet(this, _buttons).append(button, divider);
+    } else {
+      __privateGet(this, _buttons).insertBefore(button, beforeElement);
+      __privateGet(this, _buttons).insertBefore(divider, beforeElement);
+    }
     __privateSet(this, _comment, comment);
     comment.toolbar = this;
   }
@@ -12473,6 +12488,16 @@ var _EditorToolbar = class _EditorToolbar {
     __privateMethod(this, _EditorToolbar_instances, addListenersToElement_fn).call(this, button);
     __privateGet(this, _buttons).append(button, __privateGet(this, _EditorToolbar_instances, divider_get));
   }
+  removeButton(name) {
+    switch (name) {
+      case "comment":
+        __privateGet(this, _comment)?.removeToolbarCommentButton();
+        __privateSet(this, _comment, null);
+        __privateGet(this, _commentButtonDivider)?.remove();
+        __privateSet(this, _commentButtonDivider, null);
+        break;
+    }
+  }
   async addButton(name, tool) {
     switch (name) {
       case "colorPicker":
@@ -12492,6 +12517,15 @@ var _EditorToolbar = class _EditorToolbar {
         break;
     }
   }
+  async addButtonBefore(name, tool, beforeSelector) {
+    const beforeElement = __privateGet(this, _buttons).querySelector(beforeSelector);
+    if (!beforeElement) {
+      return;
+    }
+    if (name === "comment") {
+      this.addComment(tool, beforeElement);
+    }
+  }
   updateEditSignatureButton(description) {
     if (__privateGet(this, _signatureDescriptionButton)) {
       __privateGet(this, _signatureDescriptionButton).title = description;
@@ -12509,6 +12543,7 @@ _editor = new WeakMap();
 _buttons = new WeakMap();
 _altText = new WeakMap();
 _comment = new WeakMap();
+_commentButtonDivider = new WeakMap();
 _signatureDescriptionButton = new WeakMap();
 _l10nRemove = new WeakMap();
 _EditorToolbar_static = new WeakSet();
@@ -13204,6 +13239,7 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
     this.isShiftKeyDown = false;
     this._editorUndoBar = editorUndoBar || null;
     this._supportsPinchToZoom = supportsPinchToZoom !== false;
+    commentManager?.setSidebarUiManager(this);
     if (false) {
       Object.defineProperty(this, "reset", {
         value: () => {
@@ -13466,8 +13502,50 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
   hasCommentManager() {
     return !!__privateGet(this, _commentManager);
   }
-  editComment(editor, position) {
-    __privateGet(this, _commentManager)?.open(this, editor, position);
+  editComment(editor, posX, posY, options) {
+    __privateGet(this, _commentManager)?.showDialog(this, editor, posX, posY, options);
+  }
+  selectComment(pageIndex, uid) {
+    const layer = __privateGet(this, _allLayers).get(pageIndex);
+    const editor = layer?.getEditorByUID(uid);
+    editor?.toggleComment(
+      /* isSelected */
+      true,
+      /* visibility */
+      true
+    );
+  }
+  updateComment(editor) {
+    __privateGet(this, _commentManager)?.updateComment(editor.getData());
+  }
+  updatePopupColor(editor) {
+    __privateGet(this, _commentManager)?.updatePopupColor(editor);
+  }
+  removeComment(editor) {
+    __privateGet(this, _commentManager)?.removeComments([editor.uid]);
+  }
+  toggleComment(editor, isSelected, visibility = void 0) {
+    __privateGet(this, _commentManager)?.toggleCommentPopup(editor, isSelected, visibility);
+  }
+  makeCommentColor(color, opacity) {
+    return color && __privateGet(this, _commentManager)?.makeCommentColor(color, opacity) || null;
+  }
+  getCommentDialogElement() {
+    return __privateGet(this, _commentManager)?.dialogElement || null;
+  }
+  async waitForEditorsRendered(pageNumber) {
+    if (__privateGet(this, _allLayers).has(pageNumber - 1)) {
+      return;
+    }
+    const { resolve, promise } = Promise.withResolvers();
+    const onEditorsRendered = (evt) => {
+      if (evt.pageNumber === pageNumber) {
+        this._eventBus._off("editorsrendered", onEditorsRendered);
+        resolve();
+      }
+    };
+    this._eventBus.on("editorsrendered", onEditorsRendered);
+    await promise;
   }
   getSignature(editor) {
     __privateGet(this, _signatureManager)?.getSignature({ uiManager: this, editor });
@@ -13591,6 +13669,25 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
       true
     );
   }
+  /**
+   * Some annotations may have been modified in the annotation layer
+   * (e.g. comments added or modified).
+   * So this function retrieves the data from the storage and removes
+   * them from the storage in order to be able to save them later.
+   * @param {string} annotationId
+   * @returns {Object|null} The data associated to the annotation or null.
+   */
+  getAndRemoveDataFromAnnotationStorage(annotationId) {
+    if (!__privateGet(this, _annotationStorage)) {
+      return null;
+    }
+    const key = `${AnnotationEditorPrefix}${annotationId}`;
+    const storedValue = __privateGet(this, _annotationStorage).getRawValue(key);
+    if (storedValue) {
+      __privateGet(this, _annotationStorage).remove(key);
+    }
+    return storedValue;
+  }
   /**
    * Add an editor in the annotation storage.
    * @param {AnnotationEditor} editor
@@ -13909,29 +14006,57 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
     if (__privateGet(this, _mode) === AnnotationEditorType.POPUP) {
       __privateGet(this, _commentManager)?.hideSidebar();
     }
+    __privateGet(this, _commentManager)?.destroyPopup();
     __privateSet(this, _mode, mode);
     if (mode === AnnotationEditorType.NONE) {
       this.setEditingState(false);
       __privateMethod(this, _AnnotationEditorUIManager_instances, disableAll_fn).call(this);
+      for (const editor of __privateGet(this, _allEditors).values()) {
+        editor.hideStandaloneCommentButton();
+      }
       this._editorUndoBar?.hide();
+      this.toggleComment(
+        /* editor = */
+        null
+      );
       __privateGet(this, _updateModeCapability).resolve();
       return;
     }
+    for (const editor of __privateGet(this, _allEditors).values()) {
+      editor.addStandaloneCommentButton();
+    }
     if (mode === AnnotationEditorType.SIGNATURE) {
       await __privateGet(this, _signatureManager)?.loadSignatures();
     }
-    if (mode === AnnotationEditorType.POPUP) {
-      __privateGet(this, _allEditableAnnotations) || __privateSet(this, _allEditableAnnotations, await __privateGet(this, _pdfDocument).getAnnotationsByType(
-        new Set(__privateGet(this, _editorTypes).map((editorClass) => editorClass._editorType))
-      ));
-      __privateGet(this, _commentManager)?.showSidebar(__privateGet(this, _allEditableAnnotations));
-    }
     this.setEditingState(true);
     await __privateMethod(this, _AnnotationEditorUIManager_instances, enableAll_fn).call(this);
     this.unselectAll();
     for (const layer of __privateGet(this, _allLayers).values()) {
       layer.updateMode(mode);
     }
+    if (mode === AnnotationEditorType.POPUP) {
+      __privateGet(this, _allEditableAnnotations) || __privateSet(this, _allEditableAnnotations, await __privateGet(this, _pdfDocument).getAnnotationsByType(
+        new Set(__privateGet(this, _editorTypes).map((editorClass) => editorClass._editorType))
+      ));
+      const elementIds = /* @__PURE__ */ new Set();
+      const allComments = [];
+      for (const editor of __privateGet(this, _allEditors).values()) {
+        const { annotationElementId, hasComment, deleted } = editor;
+        if (annotationElementId) {
+          elementIds.add(annotationElementId);
+        }
+        if (hasComment && !deleted) {
+          allComments.push(editor.getData());
+        }
+      }
+      for (const annotation of __privateGet(this, _allEditableAnnotations)) {
+        const { id: id2, popupRef, contentsObj } = annotation;
+        if (popupRef && contentsObj?.str && !elementIds.has(id2) && !__privateGet(this, _deletedAnnotationsElementIds).has(id2)) {
+          allComments.push(annotation);
+        }
+      }
+      __privateGet(this, _commentManager)?.showSidebar(allComments);
+    }
     if (!editId) {
       if (isFromKeyboard) {
         this.addNewEditorFromKeyboard();
@@ -13940,12 +14065,14 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
       return;
     }
     for (const editor of __privateGet(this, _allEditors).values()) {
-      if (editor.annotationElementId === editId || editor.id === editId) {
+      if (editor.uid === editId) {
         this.setSelected(editor);
         if (editComment) {
           editor.editComment();
         } else if (mustEnterInEditMode) {
           editor.enterInEditMode();
+        } else {
+          editor.focus();
         }
       } else {
         editor.unselect();
@@ -14041,16 +14168,14 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
   /**
    * Get all the editors belonging to a given page.
    * @param {number} pageIndex
-   * @returns {Array<AnnotationEditor>}
+   * @yields {AnnotationEditor}
    */
-  getEditors(pageIndex) {
-    const editors = [];
+  *getEditors(pageIndex) {
     for (const editor of __privateGet(this, _allEditors).values()) {
       if (editor.pageIndex === pageIndex) {
-        editors.push(editor);
+        yield editor;
       }
     }
-    return editors;
   }
   /**
    * Get an editor with the given id.
@@ -14486,6 +14611,9 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
   getMode() {
     return __privateGet(this, _mode);
   }
+  isEditingMode() {
+    return __privateGet(this, _mode) !== AnnotationEditorType.NONE;
+  }
   get imageManager() {
     return shadow(this, "imageManager", new ImageManager());
   }
@@ -15197,72 +15325,137 @@ __publicField(_AltText, "_l10n", null);
 var AltText = _AltText;
 
 // src/pdf.js/src/display/editor/comment.js
-var _commentButton, _commentWasFromKeyBoard, _editor3, _initialText, _text, _date, _deleted;
+var _commentStandaloneButton, _commentToolbarButton, _commentWasFromKeyBoard, _editor3, _initialText, _richText, _text, _date, _deleted, _popupPosition, _Comment_instances, render_fn2;
 var Comment = class {
   constructor(editor) {
-    __privateAdd(this, _commentButton, null);
+    __privateAdd(this, _Comment_instances);
+    __privateAdd(this, _commentStandaloneButton, null);
+    __privateAdd(this, _commentToolbarButton, null);
     __privateAdd(this, _commentWasFromKeyBoard, false);
     __privateAdd(this, _editor3, null);
     __privateAdd(this, _initialText, null);
+    __privateAdd(this, _richText, null);
     __privateAdd(this, _text, null);
     __privateAdd(this, _date, null);
     __privateAdd(this, _deleted, false);
+    __privateAdd(this, _popupPosition, null);
     __privateSet(this, _editor3, editor);
-    this.toolbar = null;
   }
-  render() {
-    if (!__privateGet(this, _editor3)._uiManager.hasCommentManager()) {
+  renderForToolbar() {
+    const button = __privateSet(this, _commentToolbarButton, document.createElement("button"));
+    button.className = "comment";
+    return __privateMethod(this, _Comment_instances, render_fn2).call(this, button, false);
+  }
+  renderForStandalone() {
+    const button = __privateSet(this, _commentStandaloneButton, document.createElement("button"));
+    button.className = "annotationCommentButton";
+    const position = __privateGet(this, _editor3).commentButtonPosition;
+    if (position) {
+      const { style } = button;
+      style.insetInlineEnd = `calc(${100 * (__privateGet(this, _editor3)._uiManager.direction === "ltr" ? 1 - position[0] : position[0])}% - var(--comment-button-dim))`;
+      style.top = `calc(${100 * position[1]}% - var(--comment-button-dim))`;
+      const color = __privateGet(this, _editor3).commentButtonColor;
+      if (color) {
+        style.backgroundColor = color;
+      }
+    }
+    return __privateMethod(this, _Comment_instances, render_fn2).call(this, button, true);
+  }
+  focusButton() {
+    setTimeout(() => {
+      (__privateGet(this, _commentStandaloneButton) ?? __privateGet(this, _commentToolbarButton))?.focus();
+    }, 0);
+  }
+  onUpdatedColor() {
+    if (!__privateGet(this, _commentStandaloneButton)) {
+      return;
+    }
+    const color = __privateGet(this, _editor3).commentButtonColor;
+    if (color) {
+      __privateGet(this, _commentStandaloneButton).style.backgroundColor = color;
+    }
+    __privateGet(this, _editor3)._uiManager.updatePopupColor(__privateGet(this, _editor3));
+  }
+  get commentButtonWidth() {
+    return (__privateGet(this, _commentStandaloneButton)?.getBoundingClientRect().width ?? 0) / __privateGet(this, _editor3).parent.boundingClientRect.width;
+  }
+  get commentPopupPositionInLayer() {
+    if (__privateGet(this, _popupPosition)) {
+      return __privateGet(this, _popupPosition);
+    }
+    if (!__privateGet(this, _commentStandaloneButton)) {
       return null;
     }
-    const comment = __privateSet(this, _commentButton, document.createElement("button"));
-    comment.className = "comment";
-    comment.tabIndex = "0";
-    comment.setAttribute("data-l10n-id", "pdfjs-editor-edit-comment-button");
-    const signal = __privateGet(this, _editor3)._uiManager._signal;
-    if (!(signal instanceof AbortSignal) || signal.aborted) {
-      return comment;
+    const { x, y, height } = __privateGet(this, _commentStandaloneButton).getBoundingClientRect();
+    const {
+      x: parentX,
+      y: parentY,
+      width: parentWidth,
+      height: parentHeight
+    } = __privateGet(this, _editor3).parent.boundingClientRect;
+    return [(x - parentX) / parentWidth, (y + height - parentY) / parentHeight];
+  }
+  set commentPopupPositionInLayer(pos) {
+    __privateSet(this, _popupPosition, pos);
+  }
+  hasDefaultPopupPosition() {
+    return __privateGet(this, _popupPosition) === null;
+  }
+  removeStandaloneCommentButton() {
+    __privateGet(this, _commentStandaloneButton)?.remove();
+    __privateSet(this, _commentStandaloneButton, null);
+  }
+  removeToolbarCommentButton() {
+    __privateGet(this, _commentToolbarButton)?.remove();
+    __privateSet(this, _commentToolbarButton, null);
+  }
+  setCommentButtonStates({ selected, hasPopup }) {
+    if (!__privateGet(this, _commentStandaloneButton)) {
+      return;
     }
-    comment.addEventListener("contextmenu", noContextMenu, { signal });
-    comment.addEventListener("pointerdown", (event) => event.stopPropagation(), {
-      signal
-    });
-    const onClick = (event) => {
-      event.preventDefault();
-      this.edit();
-    };
-    comment.addEventListener("click", onClick, { capture: true, signal });
-    comment.addEventListener(
-      "keydown",
-      (event) => {
-        if (event.target === comment && event.key === "Enter") {
-          __privateSet(this, _commentWasFromKeyBoard, true);
-          onClick(event);
-        }
-      },
-      { signal }
-    );
-    return comment;
+    __privateGet(this, _commentStandaloneButton).classList.toggle("selected", selected);
+    __privateGet(this, _commentStandaloneButton).ariaExpanded = hasPopup;
   }
-  edit() {
-    const { bottom, left, right } = __privateGet(this, _editor3).getClientDimensions();
-    const position = { top: bottom };
-    if (__privateGet(this, _editor3)._uiManager.direction === "ltr") {
-      position.right = right;
+  edit(options) {
+    const position = this.commentPopupPositionInLayer;
+    let posX, posY;
+    if (position) {
+      [posX, posY] = position;
     } else {
-      position.left = left;
+      [posX, posY] = __privateGet(this, _editor3).commentButtonPosition;
+      const { width, height, x, y } = __privateGet(this, _editor3);
+      posX = x + posX * width;
+      posY = y + posY * height;
     }
-    __privateGet(this, _editor3)._uiManager.editComment(__privateGet(this, _editor3), position);
+    const parentDimensions = __privateGet(this, _editor3).parent.boundingClientRect;
+    const {
+      x: parentX,
+      y: parentY,
+      width: parentWidth,
+      height: parentHeight
+    } = parentDimensions;
+    __privateGet(this, _editor3)._uiManager.editComment(
+      __privateGet(this, _editor3),
+      parentX + posX * parentWidth,
+      parentY + posY * parentHeight,
+      { ...options, parentDimensions }
+    );
   }
   finish() {
-    if (!__privateGet(this, _commentButton)) {
+    if (!__privateGet(this, _commentToolbarButton)) {
       return;
     }
-    __privateGet(this, _commentButton).focus({ focusVisible: __privateGet(this, _commentWasFromKeyBoard) });
+    __privateGet(this, _commentToolbarButton).focus({
+      focusVisible: __privateGet(this, _commentWasFromKeyBoard)
+    });
     __privateSet(this, _commentWasFromKeyBoard, false);
   }
   isDeleted() {
     return __privateGet(this, _deleted) || __privateGet(this, _text) === "";
   }
+  isEmpty() {
+    return __privateGet(this, _text) === null;
+  }
   hasBeenEdited() {
     return this.isDeleted() || __privateGet(this, _text) !== __privateGet(this, _initialText);
   }
@@ -15272,14 +15465,18 @@ var Comment = class {
   get data() {
     return {
       text: __privateGet(this, _text),
+      richText: __privateGet(this, _richText),
       date: __privateGet(this, _date),
-      deleted: __privateGet(this, _deleted)
+      deleted: this.isDeleted()
     };
   }
   /**
    * Set the comment data.
    */
   set data(text) {
+    if (text !== __privateGet(this, _text)) {
+      __privateSet(this, _richText, null);
+    }
     if (text === null) {
       __privateSet(this, _text, "");
       __privateSet(this, _deleted, true);
@@ -15289,35 +15486,133 @@ var Comment = class {
     __privateSet(this, _date, /* @__PURE__ */ new Date());
     __privateSet(this, _deleted, false);
   }
-  setInitialText(text) {
+  setInitialText(text, richText = null) {
     __privateSet(this, _initialText, text);
     this.data = text;
-  }
-  toggle(enabled = false) {
-    if (!__privateGet(this, _commentButton)) {
-      return;
-    }
-    __privateGet(this, _commentButton).disabled = !enabled;
+    __privateSet(this, _date, null);
+    __privateSet(this, _richText, richText);
   }
   shown() {
   }
   destroy() {
-    __privateGet(this, _commentButton)?.remove();
-    __privateSet(this, _commentButton, null);
+    __privateGet(this, _commentToolbarButton)?.remove();
+    __privateSet(this, _commentToolbarButton, null);
+    __privateGet(this, _commentStandaloneButton)?.remove();
+    __privateSet(this, _commentStandaloneButton, null);
     __privateSet(this, _text, "");
+    __privateSet(this, _richText, null);
     __privateSet(this, _date, null);
     __privateSet(this, _editor3, null);
     __privateSet(this, _commentWasFromKeyBoard, false);
     __privateSet(this, _deleted, false);
   }
 };
-_commentButton = new WeakMap();
+_commentStandaloneButton = new WeakMap();
+_commentToolbarButton = new WeakMap();
 _commentWasFromKeyBoard = new WeakMap();
 _editor3 = new WeakMap();
 _initialText = new WeakMap();
+_richText = new WeakMap();
 _text = new WeakMap();
 _date = new WeakMap();
 _deleted = new WeakMap();
+_popupPosition = new WeakMap();
+_Comment_instances = new WeakSet();
+render_fn2 = function(comment, isStandalone) {
+  if (!__privateGet(this, _editor3)._uiManager.hasCommentManager()) {
+    return null;
+  }
+  comment.tabIndex = "0";
+  comment.ariaHasPopup = "dialog";
+  if (isStandalone) {
+    comment.ariaControls = "commentPopup";
+    comment.setAttribute("data-l10n-id", "pdfjs-show-comment-button");
+  } else {
+    comment.ariaControlsElements = [
+      __privateGet(this, _editor3)._uiManager.getCommentDialogElement()
+    ];
+    comment.setAttribute("data-l10n-id", "pdfjs-editor-edit-comment-button");
+  }
+  const signal = __privateGet(this, _editor3)._uiManager._signal;
+  if (!(signal instanceof AbortSignal) || signal.aborted) {
+    return comment;
+  }
+  comment.addEventListener("contextmenu", noContextMenu, { signal });
+  if (isStandalone) {
+    comment.addEventListener(
+      "focusin",
+      (e) => {
+        __privateGet(this, _editor3)._focusEventsAllowed = false;
+        stopEvent(e);
+      },
+      {
+        capture: true,
+        signal
+      }
+    );
+    comment.addEventListener(
+      "focusout",
+      (e) => {
+        __privateGet(this, _editor3)._focusEventsAllowed = true;
+        stopEvent(e);
+      },
+      {
+        capture: true,
+        signal
+      }
+    );
+  }
+  comment.addEventListener("pointerdown", (event) => event.stopPropagation(), {
+    signal
+  });
+  const onClick = (event) => {
+    event.preventDefault();
+    if (comment === __privateGet(this, _commentToolbarButton)) {
+      this.edit();
+    } else {
+      __privateGet(this, _editor3).toggleComment(
+        /* isSelected = */
+        true
+      );
+    }
+  };
+  comment.addEventListener("click", onClick, { capture: true, signal });
+  comment.addEventListener(
+    "keydown",
+    (event) => {
+      if (event.target === comment && event.key === "Enter") {
+        __privateSet(this, _commentWasFromKeyBoard, true);
+        onClick(event);
+      }
+    },
+    { signal }
+  );
+  comment.addEventListener(
+    "pointerenter",
+    () => {
+      __privateGet(this, _editor3).toggleComment(
+        /* isSelected = */
+        false,
+        /* visibility = */
+        true
+      );
+    },
+    { signal }
+  );
+  comment.addEventListener(
+    "pointerleave",
+    () => {
+      __privateGet(this, _editor3).toggleComment(
+        /* isSelected = */
+        false,
+        /* visibility = */
+        false
+      );
+    },
+    { signal }
+  );
+  return comment;
+};
 
 // src/pdf.js/src/display/touch_manager.js
 var _container2, _isPinching, _isPinchingStopped, _isPinchingDisabled, _onPinchStart, _onPinching, _onPinchEnd, _pointerDownAC, _signal, _touchInfo, _touchManagerAC, _touchMoveAC, _TouchManager_instances, onTouchStart_fn, onTouchMove_fn, onTouchEnd_fn;
@@ -15512,7 +15807,7 @@ onTouchEnd_fn = function(evt) {
 var TouchManager = _TouchManager;
 
 // src/pdf.js/src/display/editor/editor.js
-var _accessibilityData, _allResizerDivs, _altText3, _comment2, _disabled, _dragPointerId, _dragPointerType, _keepAspectRatio, _resizersDiv, _lastPointerCoords, _savedDimensions, _focusAC, _focusedResizerName, _hasBeenClicked, _initialRect, _isEditing, _isInEditMode, _isResizerEnabledForKeyboard, _moveInDOMTimeout, _prevDragX, _prevDragY, _telemetryTimeouts, _touchManager, _isDraggable, _zIndex, _AnnotationEditor_instances, translate_fn, _AnnotationEditor_static, rotatePoint_fn, getRotationMatrix_fn, createResizers_fn, resizerPointerdown_fn, resize_fn, addResizeToUndoStack_fn, resizerPointermove_fn, touchPinchStartCallback_fn, touchPinchCallback_fn, touchPinchEndCallback_fn, selectOnPointerEvent_fn, setUpDragSession_fn, addFocusListeners_fn, resizerKeydown_fn, resizerBlur_fn, resizerFocus_fn, setResizerTabIndex_fn, stopResizing_fn;
+var _accessibilityData, _allResizerDivs, _altText3, _comment2, _commentStandaloneButton2, _disabled, _dragPointerId, _dragPointerType, _resizersDiv, _lastPointerCoords, _savedDimensions, _fakeAnnotation, _focusAC, _focusedResizerName, _hasBeenClicked, _initialRect, _isEditing, _isInEditMode, _isResizerEnabledForKeyboard, _moveInDOMTimeout, _prevDragX, _prevDragY, _telemetryTimeouts, _touchManager, _isDraggable, _zIndex, _AnnotationEditor_instances, translate_fn, _AnnotationEditor_static, rotatePoint_fn, getRotationMatrix_fn, createResizers_fn, resizerPointerdown_fn, resize_fn, addResizeToUndoStack_fn, resizerPointermove_fn, touchPinchStartCallback_fn, touchPinchCallback_fn, touchPinchEndCallback_fn, selectOnPointerEvent_fn, setUpDragSession_fn, addFocusListeners_fn, resizerKeydown_fn, resizerBlur_fn, resizerFocus_fn, setResizerTabIndex_fn, stopResizing_fn;
 var _AnnotationEditor = class _AnnotationEditor {
   /**
    * @param {AnnotationEditorParameters} parameters
@@ -15523,13 +15818,14 @@ var _AnnotationEditor = class _AnnotationEditor {
     __privateAdd(this, _allResizerDivs, null);
     __privateAdd(this, _altText3, null);
     __privateAdd(this, _comment2, null);
+    __privateAdd(this, _commentStandaloneButton2, null);
     __privateAdd(this, _disabled, false);
     __privateAdd(this, _dragPointerId, null);
     __privateAdd(this, _dragPointerType, "");
-    __privateAdd(this, _keepAspectRatio, false);
     __privateAdd(this, _resizersDiv, null);
     __privateAdd(this, _lastPointerCoords, null);
     __privateAdd(this, _savedDimensions, null);
+    __privateAdd(this, _fakeAnnotation, null);
     __privateAdd(this, _focusAC, null);
     __privateAdd(this, _focusedResizerName, "");
     __privateAdd(this, _hasBeenClicked, false);
@@ -15567,6 +15863,8 @@ var _AnnotationEditor = class _AnnotationEditor {
     this._initialOptions.isCentered = parameters.isCentered;
     this._structTreeParentId = null;
     this.annotationElementId = parameters.annotationElementId || null;
+    this.creationDate = parameters.creationDate || /* @__PURE__ */ new Date();
+    this.modificationDate = parameters.modificationDate || null;
     const {
       rotation,
       rawDims: { pageWidth, pageHeight, pageX, pageY }
@@ -15706,6 +16004,9 @@ var _AnnotationEditor = class _AnnotationEditor {
     __privateSet(this, _isDraggable, value);
     this.div?.classList.toggle("draggable", value);
   }
+  get uid() {
+    return this.annotationElementId || this.id;
+  }
   /**
    * @returns {boolean} true if the editor handles the Enter key itself.
    */
@@ -15762,6 +16063,8 @@ var _AnnotationEditor = class _AnnotationEditor {
       this.pageDimensions = parent.pageDimensions;
     } else {
       __privateMethod(this, _AnnotationEditor_instances, stopResizing_fn).call(this);
+      __privateGet(this, _fakeAnnotation)?.remove();
+      __privateSet(this, _fakeAnnotation, null);
     }
     this.parent = parent;
   }
@@ -16014,32 +16317,15 @@ var _AnnotationEditor = class _AnnotationEditor {
   }
   /**
    * Set the dimensions of this editor.
-   * @param {number} width
-   * @param {number} height
    */
-  setDims(width, height) {
-    const [parentWidth, parentHeight] = this.parentDimensions;
-    const { style } = this.div;
-    style.width = `${(100 * width / parentWidth).toFixed(2)}%`;
-    if (!__privateGet(this, _keepAspectRatio)) {
-      style.height = `${(100 * height / parentHeight).toFixed(2)}%`;
-    }
-  }
-  fixDims() {
-    const { style } = this.div;
-    const { height, width } = style;
-    const widthPercent = width.endsWith("%");
-    const heightPercent = !__privateGet(this, _keepAspectRatio) && height.endsWith("%");
-    if (widthPercent && heightPercent) {
-      return;
-    }
-    const [parentWidth, parentHeight] = this.parentDimensions;
-    if (!widthPercent) {
-      style.width = `${(100 * parseFloat(width) / parentWidth).toFixed(2)}%`;
-    }
-    if (!__privateGet(this, _keepAspectRatio) && !heightPercent) {
-      style.height = `${(100 * parseFloat(height) / parentHeight).toFixed(2)}%`;
-    }
+  setDims() {
+    const {
+      div: { style },
+      width,
+      height
+    } = this;
+    style.width = `${(100 * width).toFixed(2)}%`;
+    style.height = `${(100 * height).toFixed(2)}%`;
   }
   /**
    * Get the translation used to position this editor when it's created.
@@ -16090,15 +16376,24 @@ var _AnnotationEditor = class _AnnotationEditor {
         await this._editToolbar.addButton(name, tool);
       }
     }
-    this._editToolbar.addButton("comment", this.addCommentButton());
+    if (!this.hasComment) {
+      this._editToolbar.addButton("comment", this.addCommentButton());
+    }
     this._editToolbar.addButton("delete");
     return this._editToolbar;
   }
+  addCommentButtonInToolbar() {
+    this._editToolbar?.addButtonBefore(
+      "comment",
+      this.addCommentButton(),
+      ".deleteButton"
+    );
+  }
+  removeCommentButtonFromToolbar() {
+    this._editToolbar?.removeButton("comment");
+  }
   removeEditToolbar() {
-    if (!this._editToolbar) {
-      return;
-    }
-    this._editToolbar.remove();
+    this._editToolbar?.remove();
     this._editToolbar = null;
     __privateGet(this, _altText3)?.destroy();
   }
@@ -16155,44 +16450,94 @@ var _AnnotationEditor = class _AnnotationEditor {
   hasAltTextData() {
     return __privateGet(this, _altText3)?.hasData() ?? false;
   }
+  focusCommentButton() {
+    __privateGet(this, _comment2)?.focusButton();
+  }
   addCommentButton() {
-    if (__privateGet(this, _comment2)) {
-      return __privateGet(this, _comment2);
+    return __privateGet(this, _comment2) || __privateSet(this, _comment2, new Comment(this));
+  }
+  addStandaloneCommentButton() {
+    if (__privateGet(this, _commentStandaloneButton2)) {
+      if (this._uiManager.isEditingMode()) {
+        __privateGet(this, _commentStandaloneButton2).classList.remove("hidden");
+      }
+      return;
     }
-    return __privateSet(this, _comment2, new Comment(this));
+    if (!this.hasComment) {
+      return;
+    }
+    __privateSet(this, _commentStandaloneButton2, __privateGet(this, _comment2).renderForStandalone());
+    this.div.append(__privateGet(this, _commentStandaloneButton2));
   }
-  get commentColor() {
-    return null;
+  removeStandaloneCommentButton() {
+    __privateGet(this, _comment2).removeStandaloneCommentButton();
+    __privateSet(this, _commentStandaloneButton2, null);
+  }
+  hideStandaloneCommentButton() {
+    __privateGet(this, _commentStandaloneButton2)?.classList.add("hidden");
   }
   get comment() {
-    const comment = __privateGet(this, _comment2);
+    const {
+      data: { richText, text, date, deleted }
+    } = __privateGet(this, _comment2);
     return {
-      text: comment.data.text,
-      date: comment.data.date,
-      deleted: comment.isDeleted(),
-      color: this.commentColor
+      text,
+      richText,
+      date,
+      deleted,
+      color: this.getNonHCMColor(),
+      opacity: this.opacity ?? 1
     };
   }
   set comment(text) {
-    if (!__privateGet(this, _comment2)) {
-      __privateSet(this, _comment2, new Comment(this));
-    }
+    __privateGet(this, _comment2) || __privateSet(this, _comment2, new Comment(this));
     __privateGet(this, _comment2).data = text;
+    if (this.hasComment) {
+      this.removeCommentButtonFromToolbar();
+      this.addStandaloneCommentButton();
+      this._uiManager.updateComment(this);
+    } else {
+      this.addCommentButtonInToolbar();
+      this.removeStandaloneCommentButton();
+      this._uiManager.removeComment(this);
+    }
   }
-  setCommentData(text) {
-    if (!__privateGet(this, _comment2)) {
-      __privateSet(this, _comment2, new Comment(this));
+  setCommentData({ comment, popupRef, richText }) {
+    if (!popupRef) {
+      return;
+    }
+    __privateGet(this, _comment2) || __privateSet(this, _comment2, new Comment(this));
+    __privateGet(this, _comment2).setInitialText(comment, richText);
+    if (!this.annotationElementId) {
+      return;
+    }
+    const storedData = this._uiManager.getAndRemoveDataFromAnnotationStorage(
+      this.annotationElementId
+    );
+    if (storedData) {
+      this.updateFromAnnotationLayer(storedData);
     }
-    __privateGet(this, _comment2).setInitialText(text);
   }
   get hasEditedComment() {
     return __privateGet(this, _comment2)?.hasBeenEdited();
   }
-  async editComment() {
-    if (!__privateGet(this, _comment2)) {
-      __privateSet(this, _comment2, new Comment(this));
+  get hasDeletedComment() {
+    return __privateGet(this, _comment2)?.isDeleted();
+  }
+  get hasComment() {
+    return !!__privateGet(this, _comment2) && !__privateGet(this, _comment2).isEmpty() && !__privateGet(this, _comment2).isDeleted();
+  }
+  async editComment(options) {
+    __privateGet(this, _comment2) || __privateSet(this, _comment2, new Comment(this));
+    __privateGet(this, _comment2).edit(options);
+  }
+  toggleComment(isSelected, visibility = void 0) {
+    if (this.hasComment) {
+      this._uiManager.toggleComment(this, isSelected, visibility);
     }
-    __privateGet(this, _comment2).edit();
+  }
+  setSelectedCommentButton(selected) {
+    __privateGet(this, _comment2).setSelectedButton(selected);
   }
   addComment(serialized) {
     if (this.hasEditedComment) {
@@ -16211,6 +16556,12 @@ var _AnnotationEditor = class _AnnotationEditor {
       };
     }
   }
+  updateFromAnnotationLayer({ popup: { contents, deleted } }) {
+    __privateGet(this, _comment2).data = deleted ? null : contents;
+  }
+  get parentBoundingClientRect() {
+    return this.parent.boundingClientRect;
+  }
   /**
    * Render this editor in a div.
    * @returns {HTMLDivElement | null}
@@ -16252,6 +16603,7 @@ var _AnnotationEditor = class _AnnotationEditor {
         signal: this._uiManager._signal
       }));
     }
+    this.addStandaloneCommentButton();
     this._uiManager._editorUndoBar?.hide();
     return div;
   }
@@ -16371,6 +16723,38 @@ var _AnnotationEditor = class _AnnotationEditor {
   getPDFRect() {
     return this.getRect(0, 0);
   }
+  getNonHCMColor() {
+    return this.color && _AnnotationEditor._colorManager.convert(
+      this._uiManager.getNonHCMColor(this.color)
+    );
+  }
+  /**
+   * The color has been changed.
+   */
+  onUpdatedColor() {
+    __privateGet(this, _comment2)?.onUpdatedColor();
+  }
+  getData() {
+    const {
+      comment: { text: str, color, date, opacity, deleted, richText },
+      uid: id2,
+      pageIndex,
+      creationDate,
+      modificationDate
+    } = this;
+    return {
+      id: id2,
+      pageIndex,
+      rect: this.getPDFRect(),
+      richText,
+      contentsObj: { str },
+      creationDate,
+      modificationDate: date || modificationDate,
+      popupRef: !deleted,
+      color,
+      opacity
+    };
+  }
   /**
    * Executed once this editor has been rendered.
    * @param {boolean} focus - true if the editor should be focused.
@@ -16477,7 +16861,14 @@ var _AnnotationEditor = class _AnnotationEditor {
    * @returns {Object | null}
    */
   serialize(isForCopying = false, context = null) {
-    unreachable("An editor must be serializable");
+    return {
+      annotationType: this.mode,
+      pageIndex: this.pageIndex,
+      rect: this.getPDFRect(),
+      rotation: this.rotation,
+      structTreeParentId: this._structTreeParentId,
+      popupRef: this._initialData?.popupRef || ""
+    };
   }
   /**
    * Deserialize the editor.
@@ -16493,7 +16884,9 @@ var _AnnotationEditor = class _AnnotationEditor {
       parent,
       id: parent.getNextId(),
       uiManager,
-      annotationElementId: data.annotationElementId
+      annotationElementId: data.annotationElementId,
+      creationDate: data.creationDate,
+      modificationDate: data.modificationDate
     });
     editor.rotation = data.rotation;
     __privateSet(editor, _accessibilityData, data.accessibilityData);
@@ -16566,6 +16959,47 @@ var _AnnotationEditor = class _AnnotationEditor {
   get toolbarPosition() {
     return null;
   }
+  /**
+   * Get the position of the comment button.
+   * @returns {Array<number>|null}
+   */
+  get commentButtonPosition() {
+    return this._uiManager.direction === "ltr" ? [1, 0] : [0, 0];
+  }
+  get commentButtonPositionInPage() {
+    const {
+      commentButtonPosition: [posX, posY]
+    } = this;
+    const [blX, blY, trX, trY] = this.getPDFRect();
+    return [
+      _AnnotationEditor._round(blX + (trX - blX) * posX),
+      _AnnotationEditor._round(blY + (trY - blY) * (1 - posY))
+    ];
+  }
+  get commentButtonColor() {
+    return this._uiManager.makeCommentColor(
+      this.getNonHCMColor(),
+      this.opacity
+    );
+  }
+  get commentPopupPosition() {
+    return __privateGet(this, _comment2).commentPopupPositionInLayer;
+  }
+  set commentPopupPosition(pos) {
+    __privateGet(this, _comment2).commentPopupPositionInLayer = pos;
+  }
+  hasDefaultPopupPosition() {
+    return __privateGet(this, _comment2).hasDefaultPopupPosition();
+  }
+  get commentButtonWidth() {
+    return __privateGet(this, _comment2).commentButtonWidth;
+  }
+  get elementBeforePopup() {
+    return this.div;
+  }
+  setCommentButtonStates(options) {
+    __privateGet(this, _comment2).setCommentButtonStates(options);
+  }
   /**
    * onkeydown callback.
    * @param {KeyboardEvent} event
@@ -16649,6 +17083,7 @@ var _AnnotationEditor = class _AnnotationEditor {
    */
   select() {
     if (this.isSelected && this._editToolbar) {
+      this._editToolbar.show();
       return;
     }
     this.isSelected = true;
@@ -16665,6 +17100,11 @@ var _AnnotationEditor = class _AnnotationEditor {
     this._editToolbar?.show();
     __privateGet(this, _altText3)?.toggleAltTextBadge(false);
   }
+  focus() {
+    if (this.div && !this.div.contains(document.activeElement)) {
+      setTimeout(() => this.div?.focus({ preventScroll: true }), 0);
+    }
+  }
   /**
    * Unselect this editor.
    */
@@ -16682,6 +17122,15 @@ var _AnnotationEditor = class _AnnotationEditor {
     }
     this._editToolbar?.hide();
     __privateGet(this, _altText3)?.toggleAltTextBadge(true);
+    if (this.hasComment) {
+      this._uiManager.toggleComment(
+        this,
+        /* isSelected = */
+        false,
+        /* visibility = */
+        false
+      );
+    }
   }
   /**
    * Update some parameters which have been changed through the UI.
@@ -16726,6 +17175,9 @@ var _AnnotationEditor = class _AnnotationEditor {
    * @param {MouseEvent} event
    */
   dblclick(event) {
+    if (event.target.nodeName === "BUTTON") {
+      return;
+    }
     this.enterInEditMode();
     this.parent.updateToolbar({
       mode: this.constructor._editorType,
@@ -16768,18 +17220,6 @@ var _AnnotationEditor = class _AnnotationEditor {
       this.parent.setActiveEditor(null);
     }
   }
-  /**
-   * Set the aspect ratio to use when resizing.
-   * @param {number} width
-   * @param {number} height
-   */
-  setAspectRatio(width, height) {
-    __privateSet(this, _keepAspectRatio, true);
-    const aspectRatio = width / height;
-    const { style } = this.div;
-    style.aspectRatio = aspectRatio;
-    style.height = "auto";
-  }
   static get MIN_SIZE() {
     return 16;
   }
@@ -16847,6 +17287,23 @@ var _AnnotationEditor = class _AnnotationEditor {
     }
     __privateSet(this, _disabled, true);
   }
+  updateFakeAnnotationElement(annotationLayer) {
+    if (!__privateGet(this, _fakeAnnotation) && !this.deleted) {
+      __privateSet(this, _fakeAnnotation, annotationLayer.addFakeAnnotation(this));
+      return;
+    }
+    if (this.deleted) {
+      __privateGet(this, _fakeAnnotation).remove();
+      __privateSet(this, _fakeAnnotation, null);
+      return;
+    }
+    if (this.hasEditedComment || this._hasBeenMoved || this._hasBeenResized) {
+      __privateGet(this, _fakeAnnotation).updateEdited({
+        rect: this.getPDFRect(),
+        popup: this.comment
+      });
+    }
+  }
   /**
    * Render an annotation in the annotation layer.
    * @param {Object} annotation
@@ -16881,13 +17338,14 @@ _accessibilityData = new WeakMap();
 _allResizerDivs = new WeakMap();
 _altText3 = new WeakMap();
 _comment2 = new WeakMap();
+_commentStandaloneButton2 = new WeakMap();
 _disabled = new WeakMap();
 _dragPointerId = new WeakMap();
 _dragPointerType = new WeakMap();
-_keepAspectRatio = new WeakMap();
 _resizersDiv = new WeakMap();
 _lastPointerCoords = new WeakMap();
 _savedDimensions = new WeakMap();
+_fakeAnnotation = new WeakMap();
 _focusAC = new WeakMap();
 _focusedResizerName = new WeakMap();
 _hasBeenClicked = new WeakMap();
@@ -17021,8 +17479,7 @@ resize_fn = function(x, y, width, height) {
   this.height = height;
   this.x = x;
   this.y = y;
-  const [parentWidth, parentHeight] = this.parentDimensions;
-  this.setDims(parentWidth * width, parentHeight * height);
+  this.setDims();
   this.fixAndSetPosition();
   this._onResized();
 };
@@ -17163,7 +17620,7 @@ resizerPointermove_fn = function(name, event) {
   this.height = newHeight;
   this.x = newX;
   this.y = newY;
-  this.setDims(parentWidth * newWidth, parentHeight * newHeight);
+  this.setDims();
   this.fixAndSetPosition();
   this._onResizing();
 };
@@ -17214,7 +17671,7 @@ touchPinchCallback_fn = function(_origin, prevDistance, distance) {
   this.y = centerY - newTransfCenterPoint[1];
   this.width = newWidth;
   this.height = newHeight;
-  this.setDims(parentWidth * newWidth, parentHeight * newHeight);
+  this.setDims();
   this.fixAndSetPosition();
   this._onResizing();
 };
@@ -17259,6 +17716,13 @@ setUpDragSession_fn = function(event) {
       (e) => {
         if (!hasDraggingStarted) {
           hasDraggingStarted = true;
+          this._uiManager.toggleComment(
+            this,
+            /* isSelected = */
+            true,
+            /* visibility = */
+            false
+          );
           this._onStartDragging();
         }
         const { clientX: x, clientY: y, pointerId } = e;
@@ -17366,12 +17830,13 @@ var SerializableEmpty = Object.freeze({
   hash: "",
   transfer: void 0
 });
-var _modified, _modifiedIds, _storage, _AnnotationStorage_instances, setModified_fn;
+var _modified, _modifiedIds, _editorsMap, _storage, _AnnotationStorage_instances, setModified_fn;
 var AnnotationStorage = class {
   constructor() {
     __privateAdd(this, _AnnotationStorage_instances);
     __privateAdd(this, _modified, false);
     __privateAdd(this, _modifiedIds, null);
+    __privateAdd(this, _editorsMap, null);
     __privateAdd(this, _storage, /* @__PURE__ */ new Map());
     this.onSetModified = null;
     this.onResetModified = null;
@@ -17412,6 +17877,13 @@ var AnnotationStorage = class {
    * @param {string} key
    */
   remove(key) {
+    const storedValue = __privateGet(this, _storage).get(key);
+    if (storedValue === void 0) {
+      return;
+    }
+    if (storedValue instanceof AnnotationEditor) {
+      __privateGet(this, _editorsMap).delete(storedValue.annotationElementId);
+    }
     __privateGet(this, _storage).delete(key);
     if (__privateGet(this, _storage).size === 0) {
       this.resetModified();
@@ -17447,8 +17919,11 @@ var AnnotationStorage = class {
     if (modified) {
       __privateMethod(this, _AnnotationStorage_instances, setModified_fn).call(this);
     }
-    if (value instanceof AnnotationEditor && typeof this.onAnnotationEditor === "function") {
-      this.onAnnotationEditor(value.constructor._type);
+    if (value instanceof AnnotationEditor) {
+      (__privateGet(this, _editorsMap) || __privateSet(this, _editorsMap, /* @__PURE__ */ new Map())).set(value.annotationElementId, value);
+      if (typeof this.onAnnotationEditor === "function") {
+        this.onAnnotationEditor(value.constructor._type);
+      }
     }
   }
   /**
@@ -17511,10 +17986,24 @@ var AnnotationStorage = class {
   get editorStats() {
     let stats = null;
     const typeToEditor = /* @__PURE__ */ new Map();
+    let numberOfEditedComments = 0;
+    let numberOfDeletedComments = 0;
     for (const value of __privateGet(this, _storage).values()) {
       if (!(value instanceof AnnotationEditor)) {
+        if (value.popup) {
+          if (value.popup.deleted) {
+            numberOfDeletedComments += 1;
+          } else {
+            numberOfEditedComments += 1;
+          }
+        }
         continue;
       }
+      if (value.isCommentDeleted) {
+        numberOfDeletedComments += 1;
+      } else if (value.hasEditedComment) {
+        numberOfEditedComments += 1;
+      }
       const editorStats = value.telemetryFinalData;
       if (!editorStats) {
         continue;
@@ -17538,6 +18027,16 @@ var AnnotationStorage = class {
         counters.set(val, count + 1);
       }
     }
+    if (numberOfDeletedComments > 0 || numberOfEditedComments > 0) {
+      stats || (stats = /* @__PURE__ */ Object.create(null));
+      stats.comments = {
+        deleted: numberOfDeletedComments,
+        edited: numberOfEditedComments
+      };
+    }
+    if (!stats) {
+      return null;
+    }
     for (const [type, editor] of typeToEditor) {
       stats[type] = editor.computeTelemetryFinalData(stats[type]);
     }
@@ -17546,6 +18045,17 @@ var AnnotationStorage = class {
   resetModifiedIds() {
     __privateSet(this, _modifiedIds, null);
   }
+  updateEditor(annotationId, data) {
+    const value = __privateGet(this, _editorsMap)?.get(annotationId);
+    if (value) {
+      value.updateFromAnnotationLayer(data);
+      return true;
+    }
+    return false;
+  }
+  getEditor(annotationId) {
+    return __privateGet(this, _editorsMap)?.get(annotationId) || null;
+  }
   /**
    * @returns {{ids: Set<string>, hash: string}}
    */
@@ -17554,11 +18064,13 @@ var AnnotationStorage = class {
       return __privateGet(this, _modifiedIds);
     }
     const ids = [];
-    for (const value of __privateGet(this, _storage).values()) {
-      if (!(value instanceof AnnotationEditor) || !value.annotationElementId || !value.serialize()) {
-        continue;
+    if (__privateGet(this, _editorsMap)) {
+      for (const value of __privateGet(this, _editorsMap).values()) {
+        if (!value.serialize()) {
+          continue;
+        }
+        ids.push(value.annotationElementId);
       }
-      ids.push(value.annotationElementId);
     }
     return __privateSet(this, _modifiedIds, {
       ids: new Set(ids),
@@ -17571,6 +18083,7 @@ var AnnotationStorage = class {
 };
 _modified = new WeakMap();
 _modifiedIds = new WeakMap();
+_editorsMap = new WeakMap();
 _storage = new WeakMap();
 _AnnotationStorage_instances = new WeakSet();
 setModified_fn = function() {
@@ -18139,12 +18652,12 @@ var FontLoader = class {
   }
 };
 _systemFonts = new WeakMap();
+var _fontData;
 var FontFaceObject = class {
-  constructor(translatedData, inspectFont = null) {
+  constructor(translatedData, inspectFont = null, extra, charProcOperatorList) {
+    __privateAdd(this, _fontData);
     this.compiledGlyphs = /* @__PURE__ */ Object.create(null);
-    for (const i in translatedData) {
-      this[i] = translatedData[i];
-    }
+    __privateSet(this, _fontData, translatedData);
     if (false) {
       if (typeof this.disableFontFace !== "boolean") {
         unreachable("disableFontFace must be available.");
@@ -18154,6 +18667,12 @@ var FontFaceObject = class {
       }
     }
     this._inspectFont = inspectFont;
+    if (extra) {
+      Object.assign(this, extra);
+    }
+    if (charProcOperatorList) {
+      this.charProcOperatorList = charProcOperatorList;
+    }
   }
   createNativeFontFace() {
     if (!this.data || this.disableFontFace) {
@@ -18213,7 +18732,80 @@ var FontFaceObject = class {
     }
     return this.compiledGlyphs[character] = path;
   }
+  get black() {
+    return __privateGet(this, _fontData).black;
+  }
+  get bold() {
+    return __privateGet(this, _fontData).bold;
+  }
+  get disableFontFace() {
+    return __privateGet(this, _fontData).disableFontFace ?? false;
+  }
+  get fontExtraProperties() {
+    return __privateGet(this, _fontData).fontExtraProperties ?? false;
+  }
+  get isInvalidPDFjsFont() {
+    return __privateGet(this, _fontData).isInvalidPDFjsFont;
+  }
+  get isType3Font() {
+    return __privateGet(this, _fontData).isType3Font;
+  }
+  get italic() {
+    return __privateGet(this, _fontData).italic;
+  }
+  get missingFile() {
+    return __privateGet(this, _fontData).missingFile;
+  }
+  get remeasure() {
+    return __privateGet(this, _fontData).remeasure;
+  }
+  get vertical() {
+    return __privateGet(this, _fontData).vertical;
+  }
+  get ascent() {
+    return __privateGet(this, _fontData).ascent;
+  }
+  get defaultWidth() {
+    return __privateGet(this, _fontData).defaultWidth;
+  }
+  get descent() {
+    return __privateGet(this, _fontData).descent;
+  }
+  get bbox() {
+    return __privateGet(this, _fontData).bbox;
+  }
+  get fontMatrix() {
+    return __privateGet(this, _fontData).fontMatrix;
+  }
+  get fallbackName() {
+    return __privateGet(this, _fontData).fallbackName;
+  }
+  get loadedName() {
+    return __privateGet(this, _fontData).loadedName;
+  }
+  get mimetype() {
+    return __privateGet(this, _fontData).mimetype;
+  }
+  get name() {
+    return __privateGet(this, _fontData).name;
+  }
+  get data() {
+    return __privateGet(this, _fontData).data;
+  }
+  clearData() {
+    __privateGet(this, _fontData).clearData();
+  }
+  get cssFontInfo() {
+    return __privateGet(this, _fontData).cssFontInfo;
+  }
+  get systemFontInfo() {
+    return __privateGet(this, _fontData).systemFontInfo;
+  }
+  get defaultVMetrics() {
+    return __privateGet(this, _fontData).defaultVMetrics;
+  }
 };
+_fontData = new WeakMap();
 
 // src/pdf.js/src/display/api_utils.js
 function getUrlProp(val) {
@@ -18321,9 +18913,58 @@ _deferred = new WeakMap();
 
 // src/pdf.js/src/display/canvas_dependency_tracker.js
 var FORCED_DEPENDENCY_LABEL = "__forcedDependency";
-var _simple, _incremental, _namedDependencies, _savesStack, _markedContentStack, _baseTransformStack, _clipBox, _pendingBBox, _pendingBBoxIdx, _pendingDependencies, _operations, _fontBBoxTrustworthy, _canvasWidth, _canvasHeight;
+var { floor, ceil } = Math;
+function expandBBox(array, index, minX, minY, maxX, maxY) {
+  array[index * 4 + 0] = Math.min(array[index * 4 + 0], minX);
+  array[index * 4 + 1] = Math.min(array[index * 4 + 1], minY);
+  array[index * 4 + 2] = Math.max(array[index * 4 + 2], maxX);
+  array[index * 4 + 3] = Math.max(array[index * 4 + 3], maxY);
+}
+var EMPTY_BBOX = new Uint32Array(new Uint8Array([255, 255, 0, 0]).buffer)[0];
+var _bboxes, _coords;
+var BBoxReader = class {
+  constructor(bboxes, coords) {
+    __privateAdd(this, _bboxes);
+    __privateAdd(this, _coords);
+    __privateSet(this, _bboxes, bboxes);
+    __privateSet(this, _coords, coords);
+  }
+  get length() {
+    return __privateGet(this, _bboxes).length;
+  }
+  isEmpty(i) {
+    return __privateGet(this, _bboxes)[i] === EMPTY_BBOX;
+  }
+  minX(i) {
+    return __privateGet(this, _coords)[i * 4 + 0] / 256;
+  }
+  minY(i) {
+    return __privateGet(this, _coords)[i * 4 + 1] / 256;
+  }
+  maxX(i) {
+    return (__privateGet(this, _coords)[i * 4 + 2] + 1) / 256;
+  }
+  maxY(i) {
+    return (__privateGet(this, _coords)[i * 4 + 3] + 1) / 256;
+  }
+};
+_bboxes = new WeakMap();
+_coords = new WeakMap();
+var ensureDebugMetadata = (map, key) => {
+  if (!map) {
+    return void 0;
+  }
+  let value = map.get(key);
+  if (!value) {
+    value = { dependencies: /* @__PURE__ */ new Set(), isRenderingOperation: false };
+    map.set(key, value);
+  }
+  return value;
+};
+var _simple, _incremental, _namedDependencies, _savesStack, _markedContentStack, _baseTransformStack, _clipBox, _pendingBBox, _pendingBBoxIdx, _pendingDependencies, _operations, _fontBBoxTrustworthy, _canvasWidth, _canvasHeight, _bboxesCoords, _bboxes2, _debugMetadata, _CanvasDependencyTracker_instances, initializeBBoxes_fn;
 var CanvasDependencyTracker = class {
-  constructor(canvas) {
+  constructor(canvas, operationsCount, recordDebugMetadata = false) {
+    __privateAdd(this, _CanvasDependencyTracker_instances);
     /** @type {Record<SimpleDependency, number>} */
     __privateAdd(this, _simple, { __proto__: null });
     /** @type {Record<InternalIncrementalDependency , number[]>} */
@@ -18347,8 +18988,21 @@ var CanvasDependencyTracker = class {
     __privateAdd(this, _fontBBoxTrustworthy, /* @__PURE__ */ new Map());
     __privateAdd(this, _canvasWidth);
     __privateAdd(this, _canvasHeight);
+    // Uint8ClampedArray<minX, minY, maxX, maxY>
+    __privateAdd(this, _bboxesCoords);
+    __privateAdd(this, _bboxes2);
+    __privateAdd(this, _debugMetadata);
     __privateSet(this, _canvasWidth, canvas.width);
     __privateSet(this, _canvasHeight, canvas.height);
+    __privateMethod(this, _CanvasDependencyTracker_instances, initializeBBoxes_fn).call(this, operationsCount);
+    if (recordDebugMetadata) {
+      __privateSet(this, _debugMetadata, /* @__PURE__ */ new Map());
+    }
+  }
+  growOperationsCount(operationsCount) {
+    if (operationsCount >= __privateGet(this, _bboxes2).length) {
+      __privateMethod(this, _CanvasDependencyTracker_instances, initializeBBoxes_fn).call(this, operationsCount, __privateGet(this, _bboxes2));
+    }
   }
   save(opIdx) {
     __privateSet(this, _simple, { __proto__: __privateGet(this, _simple) });
@@ -18362,7 +19016,7 @@ var CanvasDependencyTracker = class {
       }
     });
     __privateSet(this, _clipBox, { __proto__: __privateGet(this, _clipBox) });
-    __privateGet(this, _savesStack).push([opIdx, null]);
+    __privateGet(this, _savesStack).push(opIdx);
     return this;
   }
   restore(opIdx) {
@@ -18373,9 +19027,12 @@ var CanvasDependencyTracker = class {
     __privateSet(this, _simple, previous);
     __privateSet(this, _incremental, Object.getPrototypeOf(__privateGet(this, _incremental)));
     __privateSet(this, _clipBox, Object.getPrototypeOf(__privateGet(this, _clipBox)));
-    const lastPair = __privateGet(this, _savesStack).pop();
-    if (lastPair !== void 0) {
-      lastPair[1] = opIdx;
+    const lastSave = __privateGet(this, _savesStack).pop();
+    if (lastSave !== void 0) {
+      ensureDebugMetadata(__privateGet(this, _debugMetadata), opIdx)?.dependencies.add(
+        lastSave
+      );
+      __privateGet(this, _bboxes2)[opIdx] = __privateGet(this, _bboxes2)[lastSave];
     }
     return this;
   }
@@ -18383,32 +19040,38 @@ var CanvasDependencyTracker = class {
    * @param {number} idx
    */
   recordOpenMarker(idx) {
-    __privateGet(this, _savesStack).push([idx, null]);
+    __privateGet(this, _savesStack).push(idx);
     return this;
   }
   getOpenMarker() {
     if (__privateGet(this, _savesStack).length === 0) {
       return null;
     }
-    return __privateGet(this, _savesStack).at(-1)[0];
+    return __privateGet(this, _savesStack).at(-1);
   }
-  recordCloseMarker(idx) {
-    const lastPair = __privateGet(this, _savesStack).pop();
-    if (lastPair !== void 0) {
-      lastPair[1] = idx;
+  recordCloseMarker(opIdx) {
+    const lastSave = __privateGet(this, _savesStack).pop();
+    if (lastSave !== void 0) {
+      ensureDebugMetadata(__privateGet(this, _debugMetadata), opIdx)?.dependencies.add(
+        lastSave
+      );
+      __privateGet(this, _bboxes2)[opIdx] = __privateGet(this, _bboxes2)[lastSave];
     }
     return this;
   }
   // Marked content needs a separate stack from save/restore, because they
   // form two independent trees.
   beginMarkedContent(opIdx) {
-    __privateGet(this, _markedContentStack).push([opIdx, null]);
+    __privateGet(this, _markedContentStack).push(opIdx);
     return this;
   }
   endMarkedContent(opIdx) {
-    const lastPair = __privateGet(this, _markedContentStack).pop();
-    if (lastPair !== void 0) {
-      lastPair[1] = opIdx;
+    const lastSave = __privateGet(this, _markedContentStack).pop();
+    if (lastSave !== void 0) {
+      ensureDebugMetadata(__privateGet(this, _debugMetadata), opIdx)?.dependencies.add(
+        lastSave
+      );
+      __privateGet(this, _bboxes2)[opIdx] = __privateGet(this, _bboxes2)[lastSave];
     }
     return this;
   }
@@ -18455,6 +19118,14 @@ var CanvasDependencyTracker = class {
     __privateGet(this, _namedDependencies).set(name, idx);
     return this;
   }
+  /**
+   * @param {SimpleDependency} name
+   * @param {string} depName
+   * @param {number} fallbackIdx
+   */
+  recordSimpleDataFromNamed(name, depName, fallbackIdx) {
+    __privateGet(this, _simple)[name] = __privateGet(this, _namedDependencies).get(depName) ?? fallbackIdx;
+  }
   // All next operations, until the next .restore(), will depend on this
   recordFutureForcedDependency(name, idx) {
     this.recordIncrementalData(FORCED_DEPENDENCY_LABEL, idx);
@@ -18477,16 +19148,15 @@ var CanvasDependencyTracker = class {
     return this;
   }
   resetBBox(idx) {
-    __privateSet(this, _pendingBBoxIdx, idx);
-    __privateGet(this, _pendingBBox)[0] = Infinity;
-    __privateGet(this, _pendingBBox)[1] = Infinity;
-    __privateGet(this, _pendingBBox)[2] = -Infinity;
-    __privateGet(this, _pendingBBox)[3] = -Infinity;
+    if (__privateGet(this, _pendingBBoxIdx) !== idx) {
+      __privateSet(this, _pendingBBoxIdx, idx);
+      __privateGet(this, _pendingBBox)[0] = Infinity;
+      __privateGet(this, _pendingBBox)[1] = Infinity;
+      __privateGet(this, _pendingBBox)[2] = -Infinity;
+      __privateGet(this, _pendingBBox)[3] = -Infinity;
+    }
     return this;
   }
-  get hasPendingBBox() {
-    return __privateGet(this, _pendingBBoxIdx) !== -1;
-  }
   recordClipBox(idx, ctx, minX, maxX, minY, maxY) {
     const transform = Util.multiplyByDOMMatrix(
       __privateGet(this, _baseTransformStack).at(-1),
@@ -18619,17 +19289,6 @@ var CanvasDependencyTracker = class {
     }
     return this;
   }
-  copyDependenciesFromIncrementalOperation(idx, name) {
-    const operations = __privateGet(this, _operations);
-    const pendingDependencies = __privateGet(this, _pendingDependencies);
-    for (const depIdx of __privateGet(this, _incremental)[name]) {
-      operations.get(depIdx).dependencies.forEach(
-        pendingDependencies.add,
-        pendingDependencies.add(depIdx)
-      );
-    }
-    return this;
-  }
   recordNamedDependency(idx, name) {
     if (__privateGet(this, _namedDependencies).has(name)) {
       __privateGet(this, _pendingDependencies).add(__privateGet(this, _namedDependencies).get(name));
@@ -18639,32 +19298,65 @@ var CanvasDependencyTracker = class {
   /**
    * @param {number} idx
    */
-  recordOperation(idx, preserveBbox = false) {
+  recordOperation(idx, preserve = false) {
     this.recordDependencies(idx, [FORCED_DEPENDENCY_LABEL]);
-    const dependencies = new Set(__privateGet(this, _pendingDependencies));
-    const pairs = __privateGet(this, _savesStack).concat(__privateGet(this, _markedContentStack));
-    const bbox = __privateGet(this, _pendingBBoxIdx) === idx ? {
-      minX: __privateGet(this, _pendingBBox)[0],
-      minY: __privateGet(this, _pendingBBox)[1],
-      maxX: __privateGet(this, _pendingBBox)[2],
-      maxY: __privateGet(this, _pendingBBox)[3]
-    } : null;
-    __privateGet(this, _operations).set(idx, { bbox, pairs, dependencies });
-    if (!preserveBbox) {
-      __privateSet(this, _pendingBBoxIdx, -1);
+    if (__privateGet(this, _debugMetadata)) {
+      const metadata = ensureDebugMetadata(__privateGet(this, _debugMetadata), idx);
+      const { dependencies } = metadata;
+      __privateGet(this, _pendingDependencies).forEach(dependencies.add, dependencies);
+      __privateGet(this, _savesStack).forEach(dependencies.add, dependencies);
+      __privateGet(this, _markedContentStack).forEach(dependencies.add, dependencies);
+      dependencies.delete(idx);
+      metadata.isRenderingOperation = true;
+    }
+    if (__privateGet(this, _pendingBBoxIdx) === idx) {
+      const minX = floor(__privateGet(this, _pendingBBox)[0] * 256 / __privateGet(this, _canvasWidth));
+      const minY = floor(__privateGet(this, _pendingBBox)[1] * 256 / __privateGet(this, _canvasHeight));
+      const maxX = ceil(__privateGet(this, _pendingBBox)[2] * 256 / __privateGet(this, _canvasWidth));
+      const maxY = ceil(__privateGet(this, _pendingBBox)[3] * 256 / __privateGet(this, _canvasHeight));
+      expandBBox(__privateGet(this, _bboxesCoords), idx, minX, minY, maxX, maxY);
+      for (const depIdx of __privateGet(this, _pendingDependencies)) {
+        if (depIdx !== idx) {
+          expandBBox(__privateGet(this, _bboxesCoords), depIdx, minX, minY, maxX, maxY);
+        }
+      }
+      for (const saveIdx of __privateGet(this, _savesStack)) {
+        if (saveIdx !== idx) {
+          expandBBox(__privateGet(this, _bboxesCoords), saveIdx, minX, minY, maxX, maxY);
+        }
+      }
+      for (const saveIdx of __privateGet(this, _markedContentStack)) {
+        if (saveIdx !== idx) {
+          expandBBox(__privateGet(this, _bboxesCoords), saveIdx, minX, minY, maxX, maxY);
+        }
+      }
+      if (!preserve) {
+        __privateGet(this, _pendingDependencies).clear();
+        __privateSet(this, _pendingBBoxIdx, -1);
+      }
     }
-    __privateGet(this, _pendingDependencies).clear();
     return this;
   }
-  bboxToClipBoxDropOperation(idx) {
-    if (__privateGet(this, _pendingBBoxIdx) !== -1) {
+  recordShowTextOperation(idx, preserve = false) {
+    const deps = Array.from(__privateGet(this, _pendingDependencies));
+    this.recordOperation(idx, preserve);
+    this.recordIncrementalData("sameLineText", idx);
+    for (const dep of deps) {
+      this.recordIncrementalData("sameLineText", dep);
+    }
+    return this;
+  }
+  bboxToClipBoxDropOperation(idx, preserve = false) {
+    if (__privateGet(this, _pendingBBoxIdx) === idx) {
       __privateSet(this, _pendingBBoxIdx, -1);
       __privateGet(this, _clipBox)[0] = Math.max(__privateGet(this, _clipBox)[0], __privateGet(this, _pendingBBox)[0]);
       __privateGet(this, _clipBox)[1] = Math.max(__privateGet(this, _clipBox)[1], __privateGet(this, _pendingBBox)[1]);
       __privateGet(this, _clipBox)[2] = Math.min(__privateGet(this, _clipBox)[2], __privateGet(this, _pendingBBox)[2]);
       __privateGet(this, _clipBox)[3] = Math.min(__privateGet(this, _clipBox)[3], __privateGet(this, _pendingBBox)[3]);
+      if (!preserve) {
+        __privateGet(this, _pendingDependencies).clear();
+      }
     }
-    __privateGet(this, _pendingDependencies).clear();
     return this;
   }
   _takePendingDependencies() {
@@ -18684,21 +19376,10 @@ var CanvasDependencyTracker = class {
   }
   take() {
     __privateGet(this, _fontBBoxTrustworthy).clear();
-    return Array.from(
-      __privateGet(this, _operations),
-      ([idx, { bbox, pairs, dependencies }]) => {
-        pairs.forEach((pair) => pair.forEach(dependencies.add, dependencies));
-        dependencies.delete(idx);
-        return {
-          minX: (bbox?.minX ?? 0) / __privateGet(this, _canvasWidth),
-          maxX: (bbox?.maxX ?? __privateGet(this, _canvasWidth)) / __privateGet(this, _canvasWidth),
-          minY: (bbox?.minY ?? 0) / __privateGet(this, _canvasHeight),
-          maxY: (bbox?.maxY ?? __privateGet(this, _canvasHeight)) / __privateGet(this, _canvasHeight),
-          dependencies: Array.from(dependencies).sort((a, b) => a - b),
-          idx
-        };
-      }
-    );
+    return new BBoxReader(__privateGet(this, _bboxes2), __privateGet(this, _bboxesCoords));
+  }
+  takeDebugMetadata() {
+    return __privateGet(this, _debugMetadata);
   }
 };
 _simple = new WeakMap();
@@ -18715,22 +19396,40 @@ _operations = new WeakMap();
 _fontBBoxTrustworthy = new WeakMap();
 _canvasWidth = new WeakMap();
 _canvasHeight = new WeakMap();
-var _dependencyTracker, _opIdx, _nestingLevel, _outerDependencies, _savesLevel;
+_bboxesCoords = new WeakMap();
+_bboxes2 = new WeakMap();
+_debugMetadata = new WeakMap();
+_CanvasDependencyTracker_instances = new WeakSet();
+initializeBBoxes_fn = function(operationsCount, oldBBoxes) {
+  const buffer = new ArrayBuffer(operationsCount * 4);
+  __privateSet(this, _bboxesCoords, new Uint8ClampedArray(buffer));
+  __privateSet(this, _bboxes2, new Uint32Array(buffer));
+  if (oldBBoxes && oldBBoxes.length > 0) {
+    __privateGet(this, _bboxes2).set(oldBBoxes);
+    __privateGet(this, _bboxes2).fill(EMPTY_BBOX, oldBBoxes.length);
+  } else {
+    __privateGet(this, _bboxes2).fill(EMPTY_BBOX);
+  }
+};
+var _dependencyTracker, _opIdx, _ignoreBBoxes, _nestingLevel, _savesLevel;
 var _CanvasNestedDependencyTracker = class _CanvasNestedDependencyTracker {
-  constructor(dependencyTracker, opIdx) {
+  constructor(dependencyTracker, opIdx, ignoreBBoxes) {
     /** @type {CanvasDependencyTracker} */
     __privateAdd(this, _dependencyTracker);
     /** @type {number} */
     __privateAdd(this, _opIdx);
+    __privateAdd(this, _ignoreBBoxes);
     __privateAdd(this, _nestingLevel, 0);
-    __privateAdd(this, _outerDependencies);
     __privateAdd(this, _savesLevel, 0);
-    if (dependencyTracker instanceof _CanvasNestedDependencyTracker) {
+    if (dependencyTracker instanceof _CanvasNestedDependencyTracker && __privateGet(dependencyTracker, _ignoreBBoxes) === !!ignoreBBoxes) {
       return dependencyTracker;
     }
     __privateSet(this, _dependencyTracker, dependencyTracker);
-    __privateSet(this, _outerDependencies, dependencyTracker._takePendingDependencies());
     __privateSet(this, _opIdx, opIdx);
+    __privateSet(this, _ignoreBBoxes, !!ignoreBBoxes);
+  }
+  growOperationsCount() {
+    throw new Error("Unreachable");
   }
   save(opIdx) {
     __privateWrapper(this, _savesLevel)._++;
@@ -18796,6 +19495,19 @@ var _CanvasNestedDependencyTracker = class _CanvasNestedDependencyTracker {
   recordNamedData(name, idx) {
     return this;
   }
+  /**
+   * @param {SimpleDependency} name
+   * @param {string} depName
+   * @param {number} fallbackIdx
+   */
+  recordSimpleDataFromNamed(name, depName, fallbackIdx) {
+    __privateGet(this, _dependencyTracker).recordSimpleDataFromNamed(
+      name,
+      depName,
+      __privateGet(this, _opIdx)
+    );
+    return this;
+  }
   // All next operations, until the next .restore(), will depend on this
   recordFutureForcedDependency(name, idx) {
     __privateGet(this, _dependencyTracker).recordFutureForcedDependency(name, __privateGet(this, _opIdx));
@@ -18812,50 +19524,55 @@ var _CanvasNestedDependencyTracker = class _CanvasNestedDependencyTracker {
     return this;
   }
   resetBBox(idx) {
-    if (!__privateGet(this, _dependencyTracker).hasPendingBBox) {
+    if (!__privateGet(this, _ignoreBBoxes)) {
       __privateGet(this, _dependencyTracker).resetBBox(__privateGet(this, _opIdx));
     }
     return this;
   }
-  get hasPendingBBox() {
-    return __privateGet(this, _dependencyTracker).hasPendingBBox;
-  }
   recordClipBox(idx, ctx, minX, maxX, minY, maxY) {
-    __privateGet(this, _dependencyTracker).recordClipBox(
-      __privateGet(this, _opIdx),
-      ctx,
-      minX,
-      maxX,
-      minY,
-      maxY
-    );
+    if (!__privateGet(this, _ignoreBBoxes)) {
+      __privateGet(this, _dependencyTracker).recordClipBox(
+        __privateGet(this, _opIdx),
+        ctx,
+        minX,
+        maxX,
+        minY,
+        maxY
+      );
+    }
     return this;
   }
   recordBBox(idx, ctx, minX, maxX, minY, maxY) {
-    __privateGet(this, _dependencyTracker).recordBBox(
-      __privateGet(this, _opIdx),
-      ctx,
-      minX,
-      maxX,
-      minY,
-      maxY
-    );
+    if (!__privateGet(this, _ignoreBBoxes)) {
+      __privateGet(this, _dependencyTracker).recordBBox(
+        __privateGet(this, _opIdx),
+        ctx,
+        minX,
+        maxX,
+        minY,
+        maxY
+      );
+    }
     return this;
   }
   recordCharacterBBox(idx, ctx, font, scale, x, y, getMeasure) {
-    __privateGet(this, _dependencyTracker).recordCharacterBBox(
-      __privateGet(this, _opIdx),
-      ctx,
-      font,
-      scale,
-      x,
-      y,
-      getMeasure
-    );
+    if (!__privateGet(this, _ignoreBBoxes)) {
+      __privateGet(this, _dependencyTracker).recordCharacterBBox(
+        __privateGet(this, _opIdx),
+        ctx,
+        font,
+        scale,
+        x,
+        y,
+        getMeasure
+      );
+    }
     return this;
   }
   recordFullPageBBox(idx) {
-    __privateGet(this, _dependencyTracker).recordFullPageBBox(__privateGet(this, _opIdx));
+    if (!__privateGet(this, _ignoreBBoxes)) {
+      __privateGet(this, _dependencyTracker).recordFullPageBBox(__privateGet(this, _opIdx));
+    }
     return this;
   }
   getSimpleIndex(dependencyName) {
@@ -18865,13 +19582,6 @@ var _CanvasNestedDependencyTracker = class _CanvasNestedDependencyTracker {
     __privateGet(this, _dependencyTracker).recordDependencies(__privateGet(this, _opIdx), dependencyNames);
     return this;
   }
-  copyDependenciesFromIncrementalOperation(idx, name) {
-    __privateGet(this, _dependencyTracker).copyDependenciesFromIncrementalOperation(
-      __privateGet(this, _opIdx),
-      name
-    );
-    return this;
-  }
   recordNamedDependency(idx, name) {
     __privateGet(this, _dependencyTracker).recordNamedDependency(__privateGet(this, _opIdx), name);
     return this;
@@ -18882,29 +19592,29 @@ var _CanvasNestedDependencyTracker = class _CanvasNestedDependencyTracker {
    */
   recordOperation(idx) {
     __privateGet(this, _dependencyTracker).recordOperation(__privateGet(this, _opIdx), true);
-    const operation = __privateGet(this, _dependencyTracker)._extractOperation(__privateGet(this, _opIdx));
-    for (const depIdx of operation.dependencies) {
-      __privateGet(this, _outerDependencies).add(depIdx);
-    }
-    __privateGet(this, _outerDependencies).delete(__privateGet(this, _opIdx));
-    __privateGet(this, _outerDependencies).delete(null);
     return this;
   }
-  bboxToClipBoxDropOperation(idx) {
-    __privateGet(this, _dependencyTracker).bboxToClipBoxDropOperation(__privateGet(this, _opIdx));
+  recordShowTextOperation(idx) {
+    __privateGet(this, _dependencyTracker).recordShowTextOperation(__privateGet(this, _opIdx), true);
     return this;
   }
-  recordNestedDependencies() {
-    __privateGet(this, _dependencyTracker)._pushPendingDependencies(__privateGet(this, _outerDependencies));
+  bboxToClipBoxDropOperation(idx) {
+    if (!__privateGet(this, _ignoreBBoxes)) {
+      __privateGet(this, _dependencyTracker).bboxToClipBoxDropOperation(__privateGet(this, _opIdx), true);
+    }
+    return this;
   }
   take() {
     throw new Error("Unreachable");
   }
+  takeDebugMetadata() {
+    throw new Error("Unreachable");
+  }
 };
 _dependencyTracker = new WeakMap();
 _opIdx = new WeakMap();
+_ignoreBBoxes = new WeakMap();
 _nestingLevel = new WeakMap();
-_outerDependencies = new WeakMap();
 _savesLevel = new WeakMap();
 var CanvasNestedDependencyTracker = _CanvasNestedDependencyTracker;
 var Dependencies = {
@@ -18948,14 +19658,15 @@ var Dependencies = {
     "moveText",
     "textMatrix",
     "font",
+    "fontObj",
     "filter",
     "fillColor",
     "textRenderingMode",
     "SMask",
     "fillAlpha",
     "strokeAlpha",
-    "globalCompositeOperation"
-    // TODO: More
+    "globalCompositeOperation",
+    "sameLineText"
   ],
   transform: ["transform"],
   transformAndFill: ["transform", "fillColor"]
@@ -19354,7 +20065,7 @@ var _TilingPattern = class _TilingPattern {
     this.canvasGraphicsFactory = canvasGraphicsFactory;
     this.baseTransform = baseTransform;
   }
-  createPatternCanvas(owner) {
+  createPatternCanvas(owner, opIdx) {
     const {
       bbox,
       operatorList,
@@ -19407,7 +20118,7 @@ var _TilingPattern = class _TilingPattern {
       dimy.size
     );
     const tmpCtx = tmpCanvas.context;
-    const graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
+    const graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx, opIdx);
     graphics.groupLevel = owner.groupLevel;
     this.setFillAndStrokeStyleToContext(graphics, paintType, color);
     tmpCtx.translate(-dimx.scale * x0, -dimy.scale * y0);
@@ -19430,7 +20141,7 @@ var _TilingPattern = class _TilingPattern {
     graphics.baseTransform = getCurrentTransform(graphics.ctx);
     graphics.executeOperatorList(operatorList);
     graphics.endDrawing();
-    graphics.dependencyTracker?.restore().recordNestedDependencies?.();
+    graphics.dependencyTracker?.restore();
     tmpCtx.restore();
     if (redrawHorizontally || redrawVertically) {
       const image = tmpCanvas.canvas;
@@ -19532,7 +20243,7 @@ var _TilingPattern = class _TilingPattern {
   isModifyingCurrentTransform() {
     return false;
   }
-  getPattern(ctx, owner, inverse, pathType) {
+  getPattern(ctx, owner, inverse, pathType, opIdx) {
     let matrix = inverse;
     if (pathType !== PathType.SHADING) {
       matrix = Util.transform(matrix, owner.baseTransform);
@@ -19540,7 +20251,7 @@ var _TilingPattern = class _TilingPattern {
         matrix = Util.transform(matrix, this.matrix);
       }
     }
-    const temporaryPatternCanvas = this.createPatternCanvas(owner);
+    const temporaryPatternCanvas = this.createPatternCanvas(owner, opIdx);
     let domMatrix = new DOMMatrix(matrix);
     domMatrix = domMatrix.translate(
       temporaryPatternCanvas.offsetX,
@@ -20067,7 +20778,7 @@ var _CanvasGraphics = class _CanvasGraphics {
     this.viewportScale = viewport.scale;
     this.baseTransform = getCurrentTransform(this.ctx);
   }
-  executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper, filteredOperationIndexes) {
+  executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper, operationsFilter) {
     const argsArray = operatorList.argsArray;
     const fnArray = operatorList.fnArray;
     let i = executionStartIdx || 0;
@@ -20086,7 +20797,7 @@ var _CanvasGraphics = class _CanvasGraphics {
         stepper.breakIt(i, continueCallback);
         return i;
       }
-      if (!filteredOperationIndexes || filteredOperationIndexes.has(i)) {
+      if (!operationsFilter || operationsFilter(i)) {
         fnId = fnArray[i];
         fnArgs = argsArray[i] ?? null;
         if (fnId !== OPS.dependency) {
@@ -20287,7 +20998,7 @@ var _CanvasGraphics = class _CanvasGraphics {
       -offsetX,
       -offsetY
     ]);
-    fillCtx.fillStyle = isPatternFill ? fillColor.getPattern(ctx, this, inverse, PathType.FILL) : fillColor;
+    fillCtx.fillStyle = isPatternFill ? fillColor.getPattern(ctx, this, inverse, PathType.FILL, opIdx) : fillColor;
     fillCtx.fillRect(0, 0, width, height);
     if (cache && !isPatternFill) {
       this.cachedCanvases.delete("fillCanvas");
@@ -20650,7 +21361,8 @@ var _CanvasGraphics = class _CanvasGraphics {
           ctx,
           this,
           getCurrentTransformInverse(ctx),
-          PathType.STROKE
+          PathType.STROKE,
+          opIdx
         );
         if (baseTransform) {
           const newPath = new SvgPath2D();
@@ -20703,7 +21415,8 @@ var _CanvasGraphics = class _CanvasGraphics {
         ctx,
         this,
         getCurrentTransformInverse(ctx),
-        PathType.FILL
+        PathType.FILL,
+        opIdx
       );
       if (baseTransform) {
         const newPath = new SvgPath2D();
@@ -20823,7 +21536,7 @@ var _CanvasGraphics = class _CanvasGraphics {
     this.current.leading = -leading;
   }
   setFont(opIdx, fontRefName, size) {
-    this.dependencyTracker?.recordSimpleData("font", opIdx).recordNamedDependency(opIdx, fontRefName);
+    this.dependencyTracker?.recordSimpleData("font", opIdx).recordSimpleDataFromNamed("fontObj", fontRefName, opIdx);
     const fontObj = this.commonObjs.get(fontRefName);
     const current = this.current;
     if (!fontObj) {
@@ -21017,7 +21730,7 @@ var _CanvasGraphics = class _CanvasGraphics {
   }
   showText(opIdx, glyphs) {
     if (this.dependencyTracker) {
-      this.dependencyTracker.recordDependencies(opIdx, Dependencies.showText).copyDependenciesFromIncrementalOperation(opIdx, "sameLineText").resetBBox(opIdx);
+      this.dependencyTracker.recordDependencies(opIdx, Dependencies.showText).resetBBox(opIdx);
       if (this.current.textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG) {
         this.dependencyTracker.recordFutureForcedDependency("textClip", opIdx).inheritPendingDependenciesAsFutureForcedDependencies();
       }
@@ -21026,7 +21739,7 @@ var _CanvasGraphics = class _CanvasGraphics {
     const font = current.font;
     if (font.isType3Font) {
       this.showType3Text(opIdx, glyphs);
-      this.dependencyTracker?.recordOperation(opIdx).recordIncrementalData("sameLineText", opIdx);
+      this.dependencyTracker?.recordShowTextOperation(opIdx);
       return void 0;
     }
     const fontSize = current.fontSize;
@@ -21063,7 +21776,8 @@ var _CanvasGraphics = class _CanvasGraphics {
         ctx,
         this,
         getCurrentTransformInverse(ctx),
-        PathType.FILL
+        PathType.FILL,
+        opIdx
       );
       patternFillTransform = getCurrentTransform(ctx);
       ctx.restore();
@@ -21075,7 +21789,8 @@ var _CanvasGraphics = class _CanvasGraphics {
         ctx,
         this,
         getCurrentTransformInverse(ctx),
-        PathType.STROKE
+        PathType.STROKE,
+        opIdx
       );
       patternStrokeTransform = getCurrentTransform(ctx);
       ctx.restore();
@@ -21114,7 +21829,7 @@ var _CanvasGraphics = class _CanvasGraphics {
           measure.actualBoundingBoxRight,
           -measure.actualBoundingBoxAscent,
           measure.actualBoundingBoxDescent
-        ).recordOperation(opIdx).recordIncrementalData("sameLineText", opIdx);
+        ).recordShowTextOperation(opIdx);
       }
       current.x += width * widthAdvanceScale * textHScale;
       ctx.restore();
@@ -21208,7 +21923,7 @@ var _CanvasGraphics = class _CanvasGraphics {
     }
     ctx.restore();
     this.compose();
-    this.dependencyTracker?.recordOperation(opIdx).recordIncrementalData("sameLineText", opIdx);
+    this.dependencyTracker?.recordShowTextOperation(opIdx);
     return void 0;
   }
   showType3Text(opIdx, glyphs) {
@@ -21265,7 +21980,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     }
     ctx.restore();
     if (dependencyTracker) {
-      this.dependencyTracker.recordNestedDependencies();
       this.dependencyTracker = dependencyTracker;
     }
   }
@@ -21285,7 +21999,7 @@ var _CanvasGraphics = class _CanvasGraphics {
     if (IR[0] === "TilingPattern") {
       const baseTransform = this.baseTransform || getCurrentTransform(this.ctx);
       const canvasGraphicsFactory = {
-        createCanvasGraphics: (ctx) => new _CanvasGraphics(
+        createCanvasGraphics: (ctx, renderingOpIdx) => new _CanvasGraphics(
           ctx,
           this.commonObjs,
           this.objs,
@@ -21297,7 +22011,12 @@ var _CanvasGraphics = class _CanvasGraphics {
           },
           void 0,
           void 0,
-          this.dependencyTracker ? new CanvasNestedDependencyTracker(this.dependencyTracker, opIdx) : null
+          this.dependencyTracker ? new CanvasNestedDependencyTracker(
+            this.dependencyTracker,
+            renderingOpIdx,
+            /* ignoreBBoxes */
+            true
+          ) : null
         )
       };
       pattern = new TilingPattern(
@@ -21365,7 +22084,8 @@ var _CanvasGraphics = class _CanvasGraphics {
       ctx,
       this,
       getCurrentTransformInverse(ctx),
-      PathType.SHADING
+      PathType.SHADING,
+      opIdx
     );
     const inv = getCurrentTransformInverse(ctx);
     if (inv) {
@@ -21702,7 +22422,8 @@ var _CanvasGraphics = class _CanvasGraphics {
         maskCtx,
         this,
         getCurrentTransformInverse(ctx),
-        PathType.FILL
+        PathType.FILL,
+        opIdx
       ) : fillColor;
       maskCtx.fillRect(0, 0, width, height);
       maskCtx.restore();
@@ -24197,64 +24918,6 @@ __privateAdd(_TextLayer, _minFontSize, null);
 __privateAdd(_TextLayer, _pendingTextLayers, /* @__PURE__ */ new Set());
 var TextLayer = _TextLayer;
 
-// src/pdf.js/src/display/xfa_text.js
-var XfaText = class _XfaText {
-  /**
-   * Walk an XFA tree and create an array of text nodes that is compatible
-   * with a regular PDFs TextContent. Currently, only TextItem.str is supported,
-   * all other fields and styles haven't been implemented.
-   *
-   * @param {Object} xfa - An XFA fake DOM object.
-   *
-   * @returns {TextContent}
-   */
-  static textContent(xfa) {
-    const items = [];
-    const output = {
-      items,
-      styles: /* @__PURE__ */ Object.create(null)
-    };
-    function walk(node) {
-      if (!node) {
-        return;
-      }
-      let str = null;
-      const name = node.name;
-      if (name === "#text") {
-        str = node.value;
-      } else if (!_XfaText.shouldBuildText(name)) {
-        return;
-      } else if (node?.attributes?.textContent) {
-        str = node.attributes.textContent;
-      } else if (node.value) {
-        str = node.value;
-      }
-      if (str !== null) {
-        items.push({
-          str
-        });
-      }
-      if (!node.children) {
-        return;
-      }
-      for (const child of node.children) {
-        walk(child);
-      }
-    }
-    walk(xfa);
-    return output;
-  }
-  /**
-   * @param {string} name - DOM node name. (lower case)
-   *
-   * @returns {boolean} true if the DOM node should have a corresponding text
-   * node.
-   */
-  static shouldBuildText(name) {
-    return !(name === "textarea" || name === "input" || name === "option" || name === "select");
-  }
-};
-
 // src/pdf.js/src/display/api.js
 var RENDERING_CANCELLED_TIMEOUT = 100;
 function getDocument(src = {}) {
@@ -24614,9 +25277,6 @@ var PDFDocumentProxy = class {
       Object.defineProperty(this, "getXFADatasets", {
         value: () => this._transport.getXFADatasets()
       });
-      Object.defineProperty(this, "getXRefPrevValue", {
-        value: () => this._transport.getXRefPrevValue()
-      });
       Object.defineProperty(this, "getStartXRefPos", {
         value: () => this._transport.getStartXRefPos()
       });
@@ -24946,7 +25606,7 @@ var PDFPageProxy = class {
     this.objs = new PDFObjects();
     this._intentStates = /* @__PURE__ */ new Map();
     this.destroyed = false;
-    this.recordedGroups = null;
+    this.recordedBBoxes = null;
   }
   /**
    * @type {number} Page number of the page. First page is 1.
@@ -25059,7 +25719,7 @@ var PDFPageProxy = class {
     printAnnotationStorage = null,
     isEditing = false,
     recordOperations = false,
-    filteredOperationIndexes = null
+    operationsFilter = null
   }) {
     this._stats?.time("Overall");
     const intentArgs = this._transport.getRenderingIntent(
@@ -25092,18 +25752,24 @@ var PDFPageProxy = class {
       this._stats?.time("Page Request");
       this._pumpOperatorList(intentArgs);
     }
-    const shouldRecordOperations = !this.recordedGroups && (recordOperations || this._pdfBug && globalThis.StepperManager?.enabled);
+    const recordForDebugger = Boolean(
+      this._pdfBug && globalThis.StepperManager?.enabled
+    );
+    const shouldRecordOperations = !this.recordedBBoxes && (recordOperations || recordForDebugger);
     const complete = (error) => {
       intentState.renderTasks.delete(internalRenderTask);
       if (shouldRecordOperations) {
-        const recordedGroups = internalRenderTask.gfx?.dependencyTracker.take();
-        if (recordedGroups) {
-          internalRenderTask.stepper?.setOperatorGroups(recordedGroups);
+        const recordedBBoxes = internalRenderTask.gfx?.dependencyTracker.take();
+        if (recordedBBoxes) {
+          if (internalRenderTask.stepper) {
+            internalRenderTask.stepper.setOperatorBBoxes(
+              recordedBBoxes,
+              internalRenderTask.gfx.dependencyTracker.takeDebugMetadata()
+            );
+          }
           if (recordOperations) {
-            this.recordedGroups = recordedGroups;
+            this.recordedBBoxes = recordedBBoxes;
           }
-        } else if (recordOperations) {
-          this.recordedGroups = [];
         }
       }
       if (intentPrint) {
@@ -25133,7 +25799,11 @@ var PDFPageProxy = class {
       params: {
         canvas,
         canvasContext,
-        dependencyTracker: shouldRecordOperations ? new CanvasDependencyTracker(canvas) : null,
+        dependencyTracker: shouldRecordOperations ? new CanvasDependencyTracker(
+          canvas,
+          intentState.operatorList.length,
+          recordForDebugger
+        ) : null,
         viewport,
         transform,
         background
@@ -25149,7 +25819,7 @@ var PDFPageProxy = class {
       pdfBug: this._pdfBug,
       pageColors,
       enableHWA: this._transport.enableHWA,
-      filteredOperationIndexes
+      operationsFilter
     });
     (intentState.renderTasks || (intentState.renderTasks = /* @__PURE__ */ new Set())).add(internalRenderTask);
     const renderTask = internalRenderTask.task;
@@ -26061,11 +26731,17 @@ var WorkerTransport = class {
             this.commonObjs.resolve(id2, exportedError);
             break;
           }
+          const fontData = new FontInfo(exportedData);
           const inspectFont = this._params.pdfBug && globalThis.FontInspector?.enabled ? (font2, url) => globalThis.FontInspector.fontAdded(font2, url) : null;
-          const font = new FontFaceObject(exportedData, inspectFont);
+          const font = new FontFaceObject(
+            fontData,
+            inspectFont,
+            exportedData.extra,
+            exportedData.charProcOperatorList
+          );
           this.fontLoader.bind(font).catch(() => messageHandler.sendWithPromise("FontFallback", { id: id2 })).finally(() => {
             if (!font.fontExtraProperties && font.data) {
-              font.data = null;
+              font.clearData();
             }
             this.commonObjs.resolve(id2, font);
           });
@@ -26419,7 +27095,7 @@ var _InternalRenderTask = class _InternalRenderTask {
     pdfBug = false,
     pageColors = null,
     enableHWA = false,
-    filteredOperationIndexes = null
+    operationsFilter = null
   }) {
     __privateAdd(this, _rAF, null);
     this.callback = callback;
@@ -26449,7 +27125,7 @@ var _InternalRenderTask = class _InternalRenderTask {
     this._canvasContext = params.canvas ? null : params.canvasContext;
     this._enableHWA = enableHWA;
     this._dependencyTracker = params.dependencyTracker;
-    this._filteredOperationIndexes = filteredOperationIndexes;
+    this._operationsFilter = operationsFilter;
   }
   get completed() {
     return this.capability.promise.catch(function() {
@@ -26519,6 +27195,9 @@ var _InternalRenderTask = class _InternalRenderTask {
       this.graphicsReadyCallback || (this.graphicsReadyCallback = this._continueBound);
       return;
     }
+    this.gfx.dependencyTracker?.growOperationsCount(
+      this.operatorList.fnArray.length
+    );
     this.stepper?.updateOperatorList(this.operatorList);
     if (this.running) {
       return;
@@ -26555,7 +27234,7 @@ var _InternalRenderTask = class _InternalRenderTask {
       this.operatorListIdx,
       this._continueBound,
       this.stepper,
-      this._filteredOperationIndexes
+      this._operationsFilter
     );
     if (this.operatorListIdx === this.operatorList.argsArray.length) {
       this.running = false;
@@ -26925,212 +27604,6 @@ var DOMSVGFactory = class extends BaseSVGFactory {
   }
 };
 
-// src/pdf.js/src/display/xfa_layer.js
-var XfaLayer = class {
-  static setupStorage(html, id2, element, storage, intent) {
-    const storedData = storage.getValue(id2, { value: null });
-    switch (element.name) {
-      case "textarea":
-        if (storedData.value !== null) {
-          html.textContent = storedData.value;
-        }
-        if (intent === "print") {
-          break;
-        }
-        html.addEventListener("input", (event) => {
-          storage.setValue(id2, { value: event.target.value });
-        });
-        break;
-      case "input":
-        if (element.attributes.type === "radio" || element.attributes.type === "checkbox") {
-          if (storedData.value === element.attributes.xfaOn) {
-            html.setAttribute("checked", true);
-          } else if (storedData.value === element.attributes.xfaOff) {
-            html.removeAttribute("checked");
-          }
-          if (intent === "print") {
-            break;
-          }
-          html.addEventListener("change", (event) => {
-            storage.setValue(id2, {
-              value: event.target.checked ? event.target.getAttribute("xfaOn") : event.target.getAttribute("xfaOff")
-            });
-          });
-        } else {
-          if (storedData.value !== null) {
-            html.setAttribute("value", storedData.value);
-          }
-          if (intent === "print") {
-            break;
-          }
-          html.addEventListener("input", (event) => {
-            storage.setValue(id2, { value: event.target.value });
-          });
-        }
-        break;
-      case "select":
-        if (storedData.value !== null) {
-          html.setAttribute("value", storedData.value);
-          for (const option of element.children) {
-            if (option.attributes.value === storedData.value) {
-              option.attributes.selected = true;
-            } else if (option.attributes.hasOwnProperty("selected")) {
-              delete option.attributes.selected;
-            }
-          }
-        }
-        html.addEventListener("input", (event) => {
-          const options = event.target.options;
-          const value = options.selectedIndex === -1 ? "" : options[options.selectedIndex].value;
-          storage.setValue(id2, { value });
-        });
-        break;
-    }
-  }
-  static setAttributes({ html, element, storage = null, intent, linkService }) {
-    const { attributes } = element;
-    const isHTMLAnchorElement = html instanceof HTMLAnchorElement;
-    if (attributes.type === "radio") {
-      attributes.name = `${attributes.name}-${intent}`;
-    }
-    for (const [key, value] of Object.entries(attributes)) {
-      if (value === null || value === void 0) {
-        continue;
-      }
-      switch (key) {
-        case "class":
-          if (value.length) {
-            html.setAttribute(key, value.join(" "));
-          }
-          break;
-        case "dataId":
-          break;
-        case "id":
-          html.setAttribute("data-element-id", value);
-          break;
-        case "style":
-          Object.assign(html.style, value);
-          break;
-        case "textContent":
-          html.textContent = value;
-          break;
-        default:
-          if (!isHTMLAnchorElement || key !== "href" && key !== "newWindow") {
-            html.setAttribute(key, value);
-          }
-      }
-    }
-    if (isHTMLAnchorElement) {
-      linkService.addLinkAttributes(
-        html,
-        attributes.href,
-        attributes.newWindow
-      );
-    }
-    if (storage && attributes.dataId) {
-      this.setupStorage(html, attributes.dataId, element, storage);
-    }
-  }
-  /**
-   * Render the XFA layer.
-   *
-   * @param {XfaLayerParameters} parameters
-   */
-  static render(parameters) {
-    const storage = parameters.annotationStorage;
-    const linkService = parameters.linkService;
-    const root = parameters.xfaHtml;
-    const intent = parameters.intent || "display";
-    const rootHtml = document.createElement(root.name);
-    if (root.attributes) {
-      this.setAttributes({
-        html: rootHtml,
-        element: root,
-        intent,
-        linkService
-      });
-    }
-    const isNotForRichText = intent !== "richText";
-    const rootDiv = parameters.div;
-    rootDiv.append(rootHtml);
-    if (parameters.viewport) {
-      const transform = `matrix(${parameters.viewport.transform.join(",")})`;
-      rootDiv.style.transform = transform;
-    }
-    if (isNotForRichText) {
-      rootDiv.setAttribute("class", "xfaLayer xfaFont");
-    }
-    const textDivs = [];
-    if (root.children.length === 0) {
-      if (root.value) {
-        const node = document.createTextNode(root.value);
-        rootHtml.append(node);
-        if (isNotForRichText && XfaText.shouldBuildText(root.name)) {
-          textDivs.push(node);
-        }
-      }
-      return { textDivs };
-    }
-    const stack = [[root, -1, rootHtml]];
-    while (stack.length > 0) {
-      const [parent, i, html] = stack.at(-1);
-      if (i + 1 === parent.children.length) {
-        stack.pop();
-        continue;
-      }
-      const child = parent.children[++stack.at(-1)[1]];
-      if (child === null) {
-        continue;
-      }
-      const { name } = child;
-      if (name === "#text") {
-        const node = document.createTextNode(child.value);
-        textDivs.push(node);
-        html.append(node);
-        continue;
-      }
-      const childHtml = child?.attributes?.xmlns ? document.createElementNS(child.attributes.xmlns, name) : document.createElement(name);
-      html.append(childHtml);
-      if (child.attributes) {
-        this.setAttributes({
-          html: childHtml,
-          element: child,
-          storage,
-          intent,
-          linkService
-        });
-      }
-      if (child.children?.length > 0) {
-        stack.push([child, -1, childHtml]);
-      } else if (child.value) {
-        const node = document.createTextNode(child.value);
-        if (isNotForRichText && XfaText.shouldBuildText(name)) {
-          textDivs.push(node);
-        }
-        childHtml.append(node);
-      }
-    }
-    for (const el of rootDiv.querySelectorAll(
-      ".xfaNonInteractive input, .xfaNonInteractive textarea"
-    )) {
-      el.setAttribute("readOnly", true);
-    }
-    return {
-      textDivs
-    };
-  }
-  /**
-   * Update the XFA layer.
-   *
-   * @param {XfaLayerParameters} parameters
-   */
-  static update(parameters) {
-    const transform = `matrix(${parameters.viewport.transform.join(",")})`;
-    parameters.div.style.transform = transform;
-    parameters.div.hidden = false;
-  }
-};
-
 // src/pdf.js/src/display/annotation_layer.js
 var DEFAULT_FONT_SIZE2 = 9;
 var GetElementsByNameSet = /* @__PURE__ */ new WeakSet();
@@ -27200,7 +27673,7 @@ var AnnotationElementFactory = class {
     }
   }
 };
-var _updates, _hasBorder, _popupElement, _AnnotationElement_instances, changeLightness_fn, setRectEdited_fn;
+var _updates, _hasBorder, _popupElement, _AnnotationElement_instances, setRectEdited_fn;
 var _AnnotationElement = class _AnnotationElement {
   constructor(parameters, {
     isRenderable = false,
@@ -27239,13 +27712,25 @@ var _AnnotationElement = class _AnnotationElement {
     return this.data.isEditable;
   }
   get hasPopupData() {
-    return _AnnotationElement._hasPopupData(this.data);
+    return _AnnotationElement._hasPopupData(this.data) || this.enableComment && !!this.commentText;
+  }
+  get commentData() {
+    const { data } = this;
+    const editor = this.annotationStorage?.getEditor(data.id);
+    if (editor) {
+      return editor.getData();
+    }
+    return data;
   }
   get hasCommentButton() {
-    return this.enableComment && this._isEditable && this.hasPopupElement;
+    return this.enableComment && this.hasPopupElement;
   }
   get commentButtonPosition() {
-    const { quadPoints, rect } = this.data;
+    const editor = this.annotationStorage?.getEditor(this.data.id);
+    if (editor) {
+      return editor.commentButtonPositionInPage;
+    }
+    const { quadPoints, inkLists, rect } = this.data;
     let maxX = -Infinity;
     let maxY = -Infinity;
     if (quadPoints?.length >= 8) {
@@ -27259,20 +27744,26 @@ var _AnnotationElement = class _AnnotationElement {
       }
       return [maxX, maxY];
     }
+    if (inkLists?.length >= 1) {
+      for (const inkList of inkLists) {
+        for (let i = 0, ii = inkList.length; i < ii; i += 2) {
+          if (inkList[i + 1] > maxY) {
+            maxY = inkList[i + 1];
+            maxX = inkList[i];
+          } else if (inkList[i + 1] === maxY) {
+            maxX = Math.max(maxX, inkList[i]);
+          }
+        }
+      }
+      if (maxX !== Infinity) {
+        return [maxX, maxY];
+      }
+    }
     if (rect) {
       return [rect[2], rect[3]];
     }
     return null;
   }
-  get commentButtonColor() {
-    if (!this.data.color) {
-      return null;
-    }
-    const [r, g, b] = this.data.color;
-    const opacity = this.data.opacity ?? 1;
-    const oppositeOpacity = 255 * (1 - opacity);
-    return __privateMethod(this, _AnnotationElement_instances, changeLightness_fn).call(this, Math.min(r + oppositeOpacity, 255), Math.min(g + oppositeOpacity, 255), Math.min(b + oppositeOpacity, 255));
-  }
   _normalizePoint(point) {
     const {
       page: { view },
@@ -27285,6 +27776,31 @@ var _AnnotationElement = class _AnnotationElement {
     point[1] = 100 * (point[1] - pageY) / pageHeight;
     return point;
   }
+  get commentText() {
+    const { data } = this;
+    return this.annotationStorage.getRawValue(`${AnnotationEditorPrefix}${data.id}`)?.popup?.contents || data.contentsObj?.str || "";
+  }
+  set commentText(text) {
+    const { data } = this;
+    const popup = { deleted: !text, contents: text || "" };
+    if (!this.annotationStorage.updateEditor(data.id, { popup })) {
+      this.annotationStorage.setValue(`${AnnotationEditorPrefix}${data.id}`, {
+        id: data.id,
+        annotationType: data.annotationType,
+        pageIndex: this.parent.page._pageIndex,
+        popup,
+        popupRef: data.popupRef,
+        modificationDate: /* @__PURE__ */ new Date()
+      });
+    }
+    if (!text) {
+      this.removePopup();
+    }
+  }
+  removePopup() {
+    (__privateGet(this, _popupElement)?.popup || this.popup)?.remove();
+    __privateSet(this, _popupElement, this.popup = null);
+  }
   updateEdited(params) {
     if (!this.container) {
       return;
@@ -27650,11 +28166,16 @@ var _AnnotationElement = class _AnnotationElement {
       parent: this.parent,
       elements: [this]
     }));
-    this.parent.div.append(popup.render());
+    if (!this.parent._commentManager) {
+      this.parent.div.append(popup.render());
+    }
   }
   get hasPopupElement() {
     return !!(__privateGet(this, _popupElement) || this.popup || this.data.popupRef);
   }
+  get extraPopupElement() {
+    return __privateGet(this, _popupElement);
+  }
   /**
    * Render the annotation's HTML element(s).
    *
@@ -27767,30 +28288,6 @@ _updates = new WeakMap();
 _hasBorder = new WeakMap();
 _popupElement = new WeakMap();
 _AnnotationElement_instances = new WeakSet();
-changeLightness_fn = function(r, g, b) {
-  r /= 255;
-  g /= 255;
-  b /= 255;
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  const l = (max + min) / 2;
-  const newL = ((1 + Math.sqrt(l)) / 2 * 100).toFixed(2);
-  if (max === min) {
-    return `hsl(0, 0%, ${newL}%)`;
-  }
-  const d = max - min;
-  let h;
-  if (max === r) {
-    h = (g - b) / d + (g < b ? 6 : 0);
-  } else if (max === g) {
-    h = (b - r) / d + 2;
-  } else {
-    h = (r - g) / d + 4;
-  }
-  h = (h * 60).toFixed(2);
-  const s = (d / (1 - Math.abs(2 * l - 1)) * 100).toFixed(2);
-  return `hsl(${h}, ${s}%, ${newL}%)`;
-};
 setRectEdited_fn = function(rect) {
   const {
     container: { style },
@@ -27814,6 +28311,47 @@ setRectEdited_fn = function(rect) {
   }
 };
 var AnnotationElement = _AnnotationElement;
+var EditorAnnotationElement = class extends AnnotationElement {
+  constructor(parameters) {
+    super(parameters, { isRenderable: true, ignoreBorder: true });
+    this.editor = parameters.editor;
+  }
+  render() {
+    this.container.className = "editorAnnotation";
+    return this.container;
+  }
+  createOrUpdatePopup() {
+    const { editor } = this;
+    if (!editor.hasComment) {
+      return;
+    }
+    this._createPopup(editor.comment);
+    this.extraPopupElement.popup.renderCommentButton();
+  }
+  get hasCommentButton() {
+    return this.enableComment && this.editor.hasComment;
+  }
+  get commentButtonPosition() {
+    return this.editor.commentButtonPositionInPage;
+  }
+  get commentText() {
+    return this.editor.comment.text;
+  }
+  set commentText(text) {
+    this.editor.comment = text;
+    if (!text) {
+      this.removePopup();
+    }
+  }
+  get commentData() {
+    return this.editor.getData();
+  }
+  remove() {
+    this.container.remove();
+    this.container = null;
+    this.removePopup();
+  }
+};
 var _LinkAnnotationElement_instances, setInternalLink_fn, bindAttachment_fn, bindSetOCGState_fn;
 var LinkAnnotationElement = class extends AnnotationElement {
   constructor(parameters, options = null) {
@@ -28485,6 +29023,9 @@ var TextWidgetAnnotationElement = class extends WidgetAnnotationElement {
               ).valueOf();
               target.step = "";
             } else {
+              if (!value.includes("T")) {
+                value = `${value}T00:00`;
+              }
               value = new Date(value).valueOf();
             }
             target.type = "text";
@@ -29048,31 +29589,30 @@ var ChoiceWidgetAnnotationElement = class extends WidgetAnnotationElement {
     return this.container;
   }
 };
+var _PopupAnnotationElement_instances, createPopup_fn;
 var PopupAnnotationElement = class extends AnnotationElement {
   constructor(parameters) {
-    const { data, elements } = parameters;
-    super(parameters, { isRenderable: AnnotationElement._hasPopupData(data) });
+    const { data, elements, parent } = parameters;
+    const hasCommentManager = !!parent._commentManager;
+    super(parameters, {
+      isRenderable: !hasCommentManager && AnnotationElement._hasPopupData(data)
+    });
+    __privateAdd(this, _PopupAnnotationElement_instances);
     this.elements = elements;
-    this.popup = null;
+    if (hasCommentManager && AnnotationElement._hasPopupData(data)) {
+      const popup = this.popup = __privateMethod(this, _PopupAnnotationElement_instances, createPopup_fn).call(this);
+      for (const element of elements) {
+        element.popup = popup;
+      }
+    } else {
+      this.popup = null;
+    }
   }
   render() {
     const { container } = this;
     container.classList.add("popupAnnotation");
     container.role = "comment";
-    const popup = this.popup = new PopupElement({
-      container: this.container,
-      color: this.data.color,
-      titleObj: this.data.titleObj,
-      modificationDate: this.data.modificationDate || this.data.creationDate,
-      contentsObj: this.data.contentsObj,
-      richText: this.data.richText,
-      rect: this.data.rect,
-      parentRect: this.data.parentRect || null,
-      parent: this.parent,
-      elements: this.elements,
-      open: this.data.open,
-      eventBus: this.linkService.eventBus
-    });
+    const popup = this.popup = __privateMethod(this, _PopupAnnotationElement_instances, createPopup_fn).call(this);
     const elementIds = [];
     for (const element of this.elements) {
       element.popup = popup;
@@ -29087,7 +29627,24 @@ var PopupAnnotationElement = class extends AnnotationElement {
     return this.container;
   }
 };
-var _boundKeyDown, _boundHide, _boundShow, _boundToggle, _color, _container4, _contentsObj, _dateObj, _elements, _eventBus2, _parent, _parentRect, _pinned, _popup, _popupAbortController, _position2, _commentButton2, _commentButtonPosition, _commentButtonColor, _rect, _richText, _titleObj, _updates2, _wasVisible, _PopupElement_instances, addEventListeners_fn, setCommentButtonPosition_fn, renderCommentButton_fn, html_get, fontSize_get, fontColor_get, makePopupContent_fn, keyDown_fn2, setPosition_fn, toggle_fn, show_fn, hide_fn;
+_PopupAnnotationElement_instances = new WeakSet();
+createPopup_fn = function() {
+  return new PopupElement({
+    container: this.container,
+    color: this.data.color,
+    titleObj: this.data.titleObj,
+    modificationDate: this.data.modificationDate || this.data.creationDate,
+    contentsObj: this.data.contentsObj,
+    richText: this.data.richText,
+    rect: this.data.rect,
+    parentRect: this.data.parentRect || null,
+    parent: this.parent,
+    elements: this.elements,
+    open: this.data.open,
+    commentManager: this.parent._commentManager
+  });
+};
+var _commentManager2, _boundKeyDown, _boundHide, _boundShow, _boundToggle, _color, _container4, _contentsObj, _dateObj, _elements, _parent, _parentRect, _pinned, _popup, _popupAbortController, _position2, _commentButton, _commentButtonPosition, _popupPosition2, _rect, _richText2, _titleObj, _updates2, _wasVisible, _firstElement, _commentText, _PopupElement_instances, addEventListeners_fn, setCommentButtonPosition_fn, updateCommentButtonPosition_fn, updateColor_fn, html_get, fontSize_get, fontColor_get, makePopupContent_fn, keyDown_fn2, setPosition_fn, toggle_fn, show_fn, hide_fn;
 var PopupElement = class {
   constructor({
     container,
@@ -29101,9 +29658,10 @@ var PopupElement = class {
     rect,
     parentRect,
     open,
-    eventBus = null
+    commentManager = null
   }) {
     __privateAdd(this, _PopupElement_instances);
+    __privateAdd(this, _commentManager2, null);
     __privateAdd(this, _boundKeyDown, __privateMethod(this, _PopupElement_instances, keyDown_fn2).bind(this));
     __privateAdd(this, _boundHide, __privateMethod(this, _PopupElement_instances, hide_fn).bind(this));
     __privateAdd(this, _boundShow, __privateMethod(this, _PopupElement_instances, show_fn).bind(this));
@@ -29113,45 +29671,214 @@ var PopupElement = class {
     __privateAdd(this, _contentsObj, null);
     __privateAdd(this, _dateObj, null);
     __privateAdd(this, _elements, null);
-    __privateAdd(this, _eventBus2, null);
     __privateAdd(this, _parent, null);
     __privateAdd(this, _parentRect, null);
     __privateAdd(this, _pinned, false);
     __privateAdd(this, _popup, null);
     __privateAdd(this, _popupAbortController, null);
     __privateAdd(this, _position2, null);
-    __privateAdd(this, _commentButton2, null);
+    __privateAdd(this, _commentButton, null);
     __privateAdd(this, _commentButtonPosition, null);
-    __privateAdd(this, _commentButtonColor, null);
+    __privateAdd(this, _popupPosition2, null);
     __privateAdd(this, _rect, null);
-    __privateAdd(this, _richText, null);
+    __privateAdd(this, _richText2, null);
     __privateAdd(this, _titleObj, null);
     __privateAdd(this, _updates2, null);
     __privateAdd(this, _wasVisible, false);
+    __privateAdd(this, _firstElement, null);
+    __privateAdd(this, _commentText, null);
     __privateSet(this, _container4, container);
     __privateSet(this, _titleObj, titleObj);
     __privateSet(this, _contentsObj, contentsObj);
-    __privateSet(this, _richText, richText);
+    __privateSet(this, _richText2, richText);
     __privateSet(this, _parent, parent);
     __privateSet(this, _color, color);
     __privateSet(this, _rect, rect);
     __privateSet(this, _parentRect, parentRect);
     __privateSet(this, _elements, elements);
-    __privateSet(this, _eventBus2, eventBus);
+    __privateSet(this, _commentManager2, commentManager);
+    __privateSet(this, _firstElement, elements[0]);
     __privateSet(this, _dateObj, PDFDateString.toDateObject(modificationDate));
     this.trigger = elements.flatMap((e) => e.getElementsToTriggerPopup());
-    __privateMethod(this, _PopupElement_instances, addEventListeners_fn).call(this);
-    __privateGet(this, _container4).hidden = true;
-    if (open) {
-      __privateMethod(this, _PopupElement_instances, toggle_fn).call(this);
+    if (commentManager) {
+      this.renderCommentButton();
+    } else {
+      __privateMethod(this, _PopupElement_instances, addEventListeners_fn).call(this);
+      __privateGet(this, _container4).hidden = true;
+      if (open) {
+        __privateMethod(this, _PopupElement_instances, toggle_fn).call(this);
+      }
+      if (false) {
+        __privateGet(this, _parent).popupShow.push(async () => {
+          if (__privateGet(this, _container4).hidden) {
+            __privateMethod(this, _PopupElement_instances, show_fn).call(this);
+          }
+        });
+      }
     }
-    if (false) {
-      __privateGet(this, _parent).popupShow.push(async () => {
-        if (__privateGet(this, _container4).hidden) {
-          __privateMethod(this, _PopupElement_instances, show_fn).call(this);
-        }
-      });
+  }
+  renderCommentButton() {
+    if (__privateGet(this, _commentButton)) {
+      return;
+    }
+    if (!__privateGet(this, _commentButtonPosition)) {
+      __privateMethod(this, _PopupElement_instances, setCommentButtonPosition_fn).call(this);
     }
+    if (!__privateGet(this, _commentButtonPosition)) {
+      return;
+    }
+    const { signal } = __privateSet(this, _popupAbortController, new AbortController());
+    const hasOwnButton = !!__privateGet(this, _firstElement).extraPopupElement;
+    const togglePopup = () => {
+      __privateGet(this, _commentManager2).toggleCommentPopup(
+        this,
+        /* isSelected = */
+        true,
+        /* visibility = */
+        void 0,
+        /* isEditable = */
+        !hasOwnButton
+      );
+    };
+    const showPopup = () => {
+      __privateGet(this, _commentManager2).toggleCommentPopup(
+        this,
+        /* isSelected = */
+        false,
+        /* visibility = */
+        true,
+        /* isEditable = */
+        !hasOwnButton
+      );
+    };
+    const hidePopup = () => {
+      __privateGet(this, _commentManager2).toggleCommentPopup(
+        this,
+        /* isSelected = */
+        false,
+        /* visibility = */
+        false
+      );
+    };
+    if (!hasOwnButton) {
+      const button = __privateSet(this, _commentButton, document.createElement("button"));
+      button.className = "annotationCommentButton";
+      const parentContainer = __privateGet(this, _firstElement).container;
+      button.style.zIndex = parentContainer.style.zIndex + 1;
+      button.tabIndex = 0;
+      button.ariaHasPopup = "dialog";
+      button.ariaControls = "commentPopup";
+      button.setAttribute("data-l10n-id", "pdfjs-show-comment-button");
+      __privateMethod(this, _PopupElement_instances, updateColor_fn).call(this);
+      __privateMethod(this, _PopupElement_instances, updateCommentButtonPosition_fn).call(this);
+      button.addEventListener("keydown", __privateGet(this, _boundKeyDown), { signal });
+      button.addEventListener("click", togglePopup, { signal });
+      button.addEventListener("pointerenter", showPopup, { signal });
+      button.addEventListener("pointerleave", hidePopup, { signal });
+      parentContainer.after(button);
+    } else {
+      __privateSet(this, _commentButton, __privateGet(this, _firstElement).container);
+      for (const element of this.trigger) {
+        element.ariaHasPopup = "dialog";
+        element.ariaControls = "commentPopup";
+        element.addEventListener("keydown", __privateGet(this, _boundKeyDown), { signal });
+        element.addEventListener("click", togglePopup, { signal });
+        element.addEventListener("pointerenter", showPopup, { signal });
+        element.addEventListener("pointerleave", hidePopup, { signal });
+        element.classList.add("popupTriggerArea");
+      }
+    }
+  }
+  get commentButtonColor() {
+    const { color, opacity } = __privateGet(this, _firstElement).commentData;
+    if (!color) {
+      return null;
+    }
+    return __privateGet(this, _parent)._commentManager.makeCommentColor(color, opacity);
+  }
+  focusCommentButton() {
+    setTimeout(() => {
+      __privateGet(this, _commentButton)?.focus();
+    }, 0);
+  }
+  getData() {
+    const { richText, color, opacity, creationDate, modificationDate } = __privateGet(this, _firstElement).commentData;
+    return {
+      contentsObj: { str: this.comment },
+      richText,
+      color,
+      opacity,
+      creationDate,
+      modificationDate
+    };
+  }
+  get elementBeforePopup() {
+    return __privateGet(this, _commentButton);
+  }
+  get comment() {
+    __privateGet(this, _commentText) || __privateSet(this, _commentText, __privateGet(this, _firstElement).commentText);
+    return __privateGet(this, _commentText);
+  }
+  set comment(text) {
+    if (text === this.comment) {
+      return;
+    }
+    __privateGet(this, _firstElement).commentText = __privateSet(this, _commentText, text);
+  }
+  get parentBoundingClientRect() {
+    return __privateGet(this, _firstElement).layer.getBoundingClientRect();
+  }
+  setCommentButtonStates({ selected, hasPopup }) {
+    if (!__privateGet(this, _commentButton)) {
+      return;
+    }
+    __privateGet(this, _commentButton).classList.toggle("selected", selected);
+    __privateGet(this, _commentButton).ariaExpanded = hasPopup;
+  }
+  setSelectedCommentButton(selected) {
+    __privateGet(this, _commentButton).classList.toggle("selected", selected);
+  }
+  get commentPopupPosition() {
+    if (__privateGet(this, _popupPosition2)) {
+      return __privateGet(this, _popupPosition2);
+    }
+    const { x, y, height } = __privateGet(this, _commentButton).getBoundingClientRect();
+    const {
+      x: parentX,
+      y: parentY,
+      width: parentWidth,
+      height: parentHeight
+    } = __privateGet(this, _firstElement).layer.getBoundingClientRect();
+    return [(x - parentX) / parentWidth, (y + height - parentY) / parentHeight];
+  }
+  set commentPopupPosition(pos) {
+    __privateSet(this, _popupPosition2, pos);
+  }
+  hasDefaultPopupPosition() {
+    return __privateGet(this, _popupPosition2) === null;
+  }
+  get commentButtonPosition() {
+    return __privateGet(this, _commentButtonPosition);
+  }
+  get commentButtonWidth() {
+    return __privateGet(this, _commentButton).getBoundingClientRect().width / this.parentBoundingClientRect.width;
+  }
+  editComment(options) {
+    const [posX, posY] = __privateGet(this, _popupPosition2) || this.commentButtonPosition.map((x) => x / 100);
+    const parentDimensions = this.parentBoundingClientRect;
+    const {
+      x: parentX,
+      y: parentY,
+      width: parentWidth,
+      height: parentHeight
+    } = parentDimensions;
+    __privateGet(this, _commentManager2).showDialog(
+      null,
+      this,
+      parentX + posX * parentWidth,
+      parentY + posY * parentHeight,
+      { ...options, parentDimensions }
+    );
   }
   render() {
     if (__privateGet(this, _popup)) {
@@ -29188,43 +29915,36 @@ var PopupElement = class {
       modificationDate.dateTime = __privateGet(this, _dateObj).toISOString();
       header.append(modificationDate);
     }
-    const html = __privateGet(this, _PopupElement_instances, html_get);
-    if (html) {
-      XfaLayer.render({
-        xfaHtml: html,
-        intent: "richText",
-        div: popup
-      });
-      popup.lastChild.classList.add("richText", "popupContent");
-    } else {
-      const contents = this._formatContents(__privateGet(this, _contentsObj));
-      popup.append(contents);
-    }
+    renderRichText(
+      {
+        html: __privateGet(this, _PopupElement_instances, html_get) || __privateGet(this, _contentsObj).str,
+        dir: __privateGet(this, _contentsObj)?.dir,
+        className: "popupContent"
+      },
+      popup
+    );
     __privateGet(this, _container4).append(popup);
   }
-  /**
-   * Format the contents of the popup by adding newlines where necessary.
-   *
-   * @private
-   * @param {Object<string, string>} contentsObj
-   * @memberof PopupElement
-   * @returns {HTMLParagraphElement}
-   */
-  _formatContents({ str, dir }) {
-    const p = document.createElement("p");
-    p.classList.add("popupContent");
-    p.dir = dir;
-    const lines = str.split(/(?:\r\n?|\n)/);
-    for (let i = 0, ii = lines.length; i < ii; ++i) {
-      const line = lines[i];
-      p.append(document.createTextNode(line));
-      if (i < ii - 1) {
-        p.append(document.createElement("br"));
+  updateEdited({ rect, popup, deleted }) {
+    if (__privateGet(this, _commentManager2)) {
+      if (deleted) {
+        this.remove();
+        __privateSet(this, _commentText, null);
+      } else if (popup) {
+        if (popup.deleted) {
+          this.remove();
+        } else {
+          __privateMethod(this, _PopupElement_instances, updateColor_fn).call(this);
+          __privateSet(this, _commentText, popup.text);
+        }
       }
+      if (rect) {
+        __privateSet(this, _commentButtonPosition, null);
+        __privateMethod(this, _PopupElement_instances, setCommentButtonPosition_fn).call(this);
+        __privateMethod(this, _PopupElement_instances, updateCommentButtonPosition_fn).call(this);
+      }
+      return;
     }
-    return p;
-  }
-  updateEdited({ rect, popup, deleted }) {
     if (deleted || popup?.deleted) {
       this.remove();
       return;
@@ -29232,13 +29952,13 @@ var PopupElement = class {
     __privateMethod(this, _PopupElement_instances, addEventListeners_fn).call(this);
     __privateGet(this, _updates2) || __privateSet(this, _updates2, {
       contentsObj: __privateGet(this, _contentsObj),
-      richText: __privateGet(this, _richText)
+      richText: __privateGet(this, _richText2)
     });
     if (rect) {
       __privateSet(this, _position2, null);
     }
-    if (popup) {
-      __privateSet(this, _richText, __privateMethod(this, _PopupElement_instances, makePopupContent_fn).call(this, popup.text));
+    if (popup && popup.text) {
+      __privateSet(this, _richText2, __privateMethod(this, _PopupElement_instances, makePopupContent_fn).call(this, popup.text));
       __privateSet(this, _dateObj, PDFDateString.toDateObject(popup.date));
       __privateSet(this, _contentsObj, null);
     }
@@ -29249,7 +29969,7 @@ var PopupElement = class {
     if (!__privateGet(this, _updates2)) {
       return;
     }
-    ({ contentsObj: __privateWrapper(this, _contentsObj)._, richText: __privateWrapper(this, _richText)._ } = __privateGet(this, _updates2));
+    ({ contentsObj: __privateWrapper(this, _contentsObj)._, richText: __privateWrapper(this, _richText2)._ } = __privateGet(this, _updates2));
     __privateSet(this, _updates2, null);
     __privateGet(this, _popup)?.remove();
     __privateSet(this, _popup, null);
@@ -29262,8 +29982,12 @@ var PopupElement = class {
     __privateSet(this, _popup, null);
     __privateSet(this, _wasVisible, false);
     __privateSet(this, _pinned, false);
-    for (const element of this.trigger) {
-      element.classList.remove("popupTriggerArea");
+    __privateGet(this, _commentButton)?.remove();
+    __privateSet(this, _commentButton, null);
+    if (this.trigger) {
+      for (const element of this.trigger) {
+        element.classList.remove("popupTriggerArea");
+      }
     }
   }
   forceHide() {
@@ -29274,6 +29998,9 @@ var PopupElement = class {
     __privateGet(this, _container4).hidden = true;
   }
   maybeShow() {
+    if (__privateGet(this, _commentManager2)) {
+      return;
+    }
     __privateMethod(this, _PopupElement_instances, addEventListeners_fn).call(this);
     if (!__privateGet(this, _wasVisible)) {
       return;
@@ -29285,9 +30012,13 @@ var PopupElement = class {
     __privateGet(this, _container4).hidden = false;
   }
   get isVisible() {
+    if (__privateGet(this, _commentManager2)) {
+      return false;
+    }
     return __privateGet(this, _container4).hidden === false;
   }
 };
+_commentManager2 = new WeakMap();
 _boundKeyDown = new WeakMap();
 _boundHide = new WeakMap();
 _boundShow = new WeakMap();
@@ -29297,21 +30028,22 @@ _container4 = new WeakMap();
 _contentsObj = new WeakMap();
 _dateObj = new WeakMap();
 _elements = new WeakMap();
-_eventBus2 = new WeakMap();
 _parent = new WeakMap();
 _parentRect = new WeakMap();
 _pinned = new WeakMap();
 _popup = new WeakMap();
 _popupAbortController = new WeakMap();
 _position2 = new WeakMap();
-_commentButton2 = new WeakMap();
+_commentButton = new WeakMap();
 _commentButtonPosition = new WeakMap();
-_commentButtonColor = new WeakMap();
+_popupPosition2 = new WeakMap();
 _rect = new WeakMap();
-_richText = new WeakMap();
+_richText2 = new WeakMap();
 _titleObj = new WeakMap();
 _updates2 = new WeakMap();
 _wasVisible = new WeakMap();
+_firstElement = new WeakMap();
+_commentText = new WeakMap();
 _PopupElement_instances = new WeakSet();
 addEventListeners_fn = function() {
   if (__privateGet(this, _popupAbortController)) {
@@ -29321,8 +30053,8 @@ addEventListeners_fn = function() {
   const { signal } = __privateGet(this, _popupAbortController);
   for (const element of this.trigger) {
     element.addEventListener("click", __privateGet(this, _boundToggle), { signal });
-    element.addEventListener("mouseenter", __privateGet(this, _boundShow), { signal });
-    element.addEventListener("mouseleave", __privateGet(this, _boundHide), { signal });
+    element.addEventListener("pointerenter", __privateGet(this, _boundShow), { signal });
+    element.addEventListener("pointerleave", __privateGet(this, _boundHide), { signal });
     element.classList.add("popupTriggerArea");
   }
   for (const element of __privateGet(this, _elements)) {
@@ -29330,7 +30062,6 @@ addEventListeners_fn = function() {
       signal
     });
   }
-  __privateMethod(this, _PopupElement_instances, renderCommentButton_fn).call(this);
 };
 setCommentButtonPosition_fn = function() {
   const element = __privateGet(this, _elements).find((e) => e.hasCommentButton);
@@ -29340,57 +30071,29 @@ setCommentButtonPosition_fn = function() {
   __privateSet(this, _commentButtonPosition, element._normalizePoint(
     element.commentButtonPosition
   ));
-  __privateSet(this, _commentButtonColor, element.commentButtonColor);
 };
-renderCommentButton_fn = function() {
-  if (__privateGet(this, _commentButton2)) {
+updateCommentButtonPosition_fn = function() {
+  if (__privateGet(this, _firstElement).extraPopupElement && !__privateGet(this, _firstElement).editor) {
     return;
   }
-  if (!__privateGet(this, _commentButtonPosition)) {
-    __privateMethod(this, _PopupElement_instances, setCommentButtonPosition_fn).call(this);
-  }
-  if (!__privateGet(this, _commentButtonPosition)) {
+  this.renderCommentButton();
+  const [x, y] = __privateGet(this, _commentButtonPosition);
+  const { style } = __privateGet(this, _commentButton);
+  style.left = `calc(${x}%)`;
+  style.top = `calc(${y}% - var(--comment-button-dim))`;
+};
+updateColor_fn = function() {
+  if (__privateGet(this, _firstElement).extraPopupElement) {
     return;
   }
-  const button = __privateSet(this, _commentButton2, document.createElement("button"));
-  button.className = "annotationCommentButton";
-  const parentContainer = __privateGet(this, _elements)[0].container;
-  button.style.zIndex = parentContainer.style.zIndex + 1;
-  button.tabIndex = 0;
-  const { signal } = __privateGet(this, _popupAbortController);
-  button.addEventListener("hover", __privateGet(this, _boundToggle), { signal });
-  button.addEventListener("keydown", __privateGet(this, _boundKeyDown), { signal });
-  button.addEventListener(
-    "click",
-    () => {
-      const [
-        {
-          data: { id: editId },
-          annotationEditorType: mode
-        }
-      ] = __privateGet(this, _elements);
-      __privateGet(this, _eventBus2)?.dispatch("switchannotationeditormode", {
-        source: this,
-        editId,
-        mode,
-        editComment: true
-      });
-    },
-    { signal }
-  );
-  const { style } = button;
-  style.left = `calc(${__privateGet(this, _commentButtonPosition)[0]}%)`;
-  style.top = `calc(${__privateGet(this, _commentButtonPosition)[1]}% - var(--comment-button-dim))`;
-  if (__privateGet(this, _commentButtonColor)) {
-    style.backgroundColor = __privateGet(this, _commentButtonColor);
-  }
-  parentContainer.after(button);
+  this.renderCommentButton();
+  __privateGet(this, _commentButton).style.backgroundColor = this.commentButtonColor || "";
 };
 html_get = function() {
-  const richText = __privateGet(this, _richText);
+  const richText = __privateGet(this, _richText2);
   const contentsObj = __privateGet(this, _contentsObj);
   if (richText?.str && (!contentsObj?.str || contentsObj.str === richText.str)) {
-    return __privateGet(this, _richText).html || null;
+    return __privateGet(this, _richText2).html || null;
   }
   return null;
 };
@@ -29481,6 +30184,14 @@ setPosition_fn = function() {
  * Toggle the visibility of the popup.
  */
 toggle_fn = function() {
+  if (__privateGet(this, _commentManager2)) {
+    __privateGet(this, _commentManager2).toggleCommentPopup(
+      this,
+      /* isSelected = */
+      false
+    );
+    return;
+  }
   __privateSet(this, _pinned, !__privateGet(this, _pinned));
   if (__privateGet(this, _pinned)) {
     __privateMethod(this, _PopupElement_instances, show_fn).call(this);
@@ -29803,30 +30514,6 @@ var InkAnnotationElement = class extends AnnotationElement {
   addHighlightArea() {
     this.container.classList.add("highlightArea");
   }
-  get commentButtonPosition() {
-    const { inkLists, rect } = this.data;
-    if (inkLists?.length >= 1) {
-      let maxX = -Infinity;
-      let maxY = -Infinity;
-      for (const inkList of inkLists) {
-        for (let i = 0, ii = inkList.length; i < ii; i += 2) {
-          if (inkList[i + 1] > maxY) {
-            maxY = inkList[i + 1];
-            maxX = inkList[i];
-          } else if (inkList[i + 1] === maxY) {
-            maxX = Math.max(maxX, inkList[i]);
-          }
-        }
-      }
-      if (maxX !== Infinity) {
-        return [maxX, maxY];
-      }
-    }
-    if (rect) {
-      return [rect[2], rect[3]];
-    }
-    return null;
-  }
 };
 _polylinesGroupElement = new WeakMap();
 _polylines = new WeakMap();
@@ -30039,7 +30726,7 @@ _FileAttachmentAnnotationElement_instances = new WeakSet();
 download_fn = function() {
   this.downloadManager?.openOrDownloadData(this.content, this.filename);
 };
-var _accessibilityManager, _annotationCanvasMap, _editableAnnotations, _structTreeLayer, _AnnotationLayer_instances, appendElement_fn, setAnnotationCanvasMap_fn;
+var _accessibilityManager, _annotationCanvasMap, _annotationStorage2, _editableAnnotations, _structTreeLayer, _linkService, _AnnotationLayer_instances, appendElement_fn, setAnnotationCanvasMap_fn;
 var _AnnotationLayer = class _AnnotationLayer {
   constructor({
     div,
@@ -30048,21 +30735,29 @@ var _AnnotationLayer = class _AnnotationLayer {
     annotationEditorUIManager,
     page,
     viewport,
-    structTreeLayer
+    structTreeLayer,
+    commentManager,
+    linkService,
+    annotationStorage
   }) {
     __privateAdd(this, _AnnotationLayer_instances);
     __privateAdd(this, _accessibilityManager, null);
     __privateAdd(this, _annotationCanvasMap, null);
+    __privateAdd(this, _annotationStorage2, null);
     __privateAdd(this, _editableAnnotations, /* @__PURE__ */ new Map());
     __privateAdd(this, _structTreeLayer, null);
+    __privateAdd(this, _linkService, null);
     this.div = div;
     __privateSet(this, _accessibilityManager, accessibilityManager);
     __privateSet(this, _annotationCanvasMap, annotationCanvasMap);
     __privateSet(this, _structTreeLayer, structTreeLayer || null);
+    __privateSet(this, _linkService, linkService || null);
+    __privateSet(this, _annotationStorage2, annotationStorage || new AnnotationStorage());
     this.page = page;
     this.viewport = viewport;
     this.zIndex = 0;
     this._annotationEditorUIManager = annotationEditorUIManager;
+    this._commentManager = commentManager || null;
     if (false) {
       Object.defineProperty(this, "showPopups", {
         value: async () => {
@@ -30091,12 +30786,12 @@ var _AnnotationLayer = class _AnnotationLayer {
     const elementParams = {
       data: null,
       layer,
-      linkService: params.linkService,
+      linkService: __privateGet(this, _linkService),
       downloadManager: params.downloadManager,
       imageResourcesPath: params.imageResourcesPath || "",
       renderForms: params.renderForms !== false,
       svgFactory: new DOMSVGFactory(),
-      annotationStorage: params.annotationStorage || new AnnotationStorage(),
+      annotationStorage: __privateGet(this, _annotationStorage2),
       enableComment: params.enableComment === true,
       enableScripting: params.enableScripting === true,
       hasJSActions: params.hasJSActions,
@@ -30138,6 +30833,7 @@ var _AnnotationLayer = class _AnnotationLayer {
         rendered.style.visibility = "hidden";
       }
       await __privateMethod(this, _AnnotationLayer_instances, appendElement_fn).call(this, rendered, data.id, elementParams.elements);
+      element.extraPopupElement?.popup?.renderCommentButton();
       if (element._isEditable) {
         __privateGet(this, _editableAnnotations).set(element.data.id, element);
         this._annotationEditorUIManager?.renderAnnotationElement(element);
@@ -30152,11 +30848,11 @@ var _AnnotationLayer = class _AnnotationLayer {
    * @param {IPDFLinkService} linkService
    * @memberof AnnotationLayer
    */
-  async addLinkAnnotations(annotations, linkService) {
+  async addLinkAnnotations(annotations) {
     const elementParams = {
       data: null,
       layer: this.div,
-      linkService,
+      linkService: __privateGet(this, _linkService),
       svgFactory: new DOMSVGFactory(),
       parent: this
     };
@@ -30190,6 +30886,34 @@ var _AnnotationLayer = class _AnnotationLayer {
   getEditableAnnotation(id2) {
     return __privateGet(this, _editableAnnotations).get(id2);
   }
+  addFakeAnnotation(editor) {
+    const { div } = this;
+    const { id: id2, rotation } = editor;
+    const element = new EditorAnnotationElement({
+      data: {
+        id: id2,
+        rect: editor.getPDFRect(),
+        rotation
+      },
+      editor,
+      layer: div,
+      parent: this,
+      enableComment: !!this._commentManager,
+      linkService: __privateGet(this, _linkService),
+      annotationStorage: __privateGet(this, _annotationStorage2)
+    });
+    const htmlElement = element.render();
+    div.append(htmlElement);
+    __privateGet(this, _accessibilityManager)?.moveElementInDOM(
+      div,
+      htmlElement,
+      htmlElement,
+      /* isRemovable = */
+      false
+    );
+    element.createOrUpdatePopup();
+    return element;
+  }
   /**
    * @private
    */
@@ -30210,8 +30934,10 @@ var _AnnotationLayer = class _AnnotationLayer {
 };
 _accessibilityManager = new WeakMap();
 _annotationCanvasMap = new WeakMap();
+_annotationStorage2 = new WeakMap();
 _editableAnnotations = new WeakMap();
 _structTreeLayer = new WeakMap();
+_linkService = new WeakMap();
 _AnnotationLayer_instances = new WeakSet();
 appendElement_fn = async function(element, id2, popupElements) {
   const contentElement = element.firstChild || element;
@@ -30277,18 +31003,17 @@ var AnnotationLayer = _AnnotationLayer;
 
 // src/pdf.js/src/display/editor/freetext.js
 var EOL_PATTERN = /\r\n?|\n/g;
-var _color2, _content, _editorDivId, _editModeAC, _fontSize, _FreeTextEditor_instances, updateFontSize_fn, updateColor_fn, extractText_fn, setEditorDimensions_fn, _FreeTextEditor_static, getNodeContent_fn, setContent_fn, serializeContent_fn, deserializeContent_fn, hasElementChanged_fn;
+var _content, _editorDivId, _editModeAC, _fontSize, _FreeTextEditor_instances, updateFontSize_fn, updateColor_fn2, extractText_fn, setEditorDimensions_fn, _FreeTextEditor_static, getNodeContent_fn, setContent_fn, serializeContent_fn, deserializeContent_fn, hasElementChanged_fn;
 var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
   constructor(params) {
     super({ ...params, name: "freeTextEditor" });
     __privateAdd(this, _FreeTextEditor_instances);
-    __privateAdd(this, _color2);
     __privateAdd(this, _content, "");
     __privateAdd(this, _editorDivId, `${this.id}-editor`);
     __privateAdd(this, _editModeAC, null);
     __privateAdd(this, _fontSize);
     __publicField(this, "_colorPicker", null);
-    __privateSet(this, _color2, params.color || _FreeTextEditor._defaultColor || AnnotationEditor._defaultLineColor);
+    this.color = params.color || _FreeTextEditor._defaultColor || AnnotationEditor._defaultLineColor;
     __privateSet(this, _fontSize, params.fontSize || _FreeTextEditor._defaultFontSize);
     if (!this.annotationElementId) {
       this._uiManager.a11yAlert("pdfjs-editor-freetext-added-alert");
@@ -30393,7 +31118,7 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
         __privateMethod(this, _FreeTextEditor_instances, updateFontSize_fn).call(this, value);
         break;
       case AnnotationEditorParamsType.FREETEXT_COLOR:
-        __privateMethod(this, _FreeTextEditor_instances, updateColor_fn).call(this, value);
+        __privateMethod(this, _FreeTextEditor_instances, updateColor_fn2).call(this, value);
         break;
     }
   }
@@ -30414,7 +31139,7 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
   get propertiesToUpdate() {
     return [
       [AnnotationEditorParamsType.FREETEXT_SIZE, __privateGet(this, _fontSize)],
-      [AnnotationEditorParamsType.FREETEXT_COLOR, __privateGet(this, _color2)]
+      [AnnotationEditorParamsType.FREETEXT_COLOR, this.color]
     ];
   }
   /** @inheritdoc */
@@ -30425,8 +31150,11 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
   get colorType() {
     return AnnotationEditorParamsType.FREETEXT_COLOR;
   }
-  get colorValue() {
-    return __privateGet(this, _color2);
+  /** @inheritdoc */
+  onUpdatedColor() {
+    this.editorDiv.style.color = this.color;
+    this._colorPicker?.update(this.color);
+    super.onUpdatedColor();
   }
   /**
    * Helper to translate the editor with the keyboard when it's empty.
@@ -30651,7 +31379,7 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     this.editorDiv.contentEditable = true;
     const { style } = this.editorDiv;
     style.fontSize = `calc(${__privateGet(this, _fontSize)}px * var(--total-scale-factor))`;
-    style.color = __privateGet(this, _color2);
+    style.color = this.color;
     this.div.append(this.editorDiv);
     this.overlayDiv = document.createElement("div");
     this.overlayDiv.classList.add("overlay", "enabled");
@@ -30797,7 +31525,10 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
           rotation,
           id: id2,
           popupRef,
-          contentsObj
+          richText,
+          contentsObj,
+          creationDate,
+          modificationDate
         },
         textContent,
         textPosition,
@@ -30821,16 +31552,19 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
         id: id2,
         deleted: false,
         popupRef,
-        comment: contentsObj?.str || null
+        comment: contentsObj?.str || null,
+        richText,
+        creationDate,
+        modificationDate
       };
     }
     const editor = await super.deserialize(data, parent, uiManager);
     __privateSet(editor, _fontSize, data.fontSize);
-    __privateSet(editor, _color2, Util.makeHexColor(...data.color));
+    editor.color = Util.makeHexColor(...data.color);
     __privateSet(editor, _content, __privateMethod(_a2 = _FreeTextEditor, _FreeTextEditor_static, deserializeContent_fn).call(_a2, data.value));
     editor._initialData = initialData;
     if (data.comment) {
-      editor.setCommentData(data.comment);
+      editor.setCommentData(data);
     }
     return editor;
   }
@@ -30842,20 +31576,14 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     if (this.deleted) {
       return this.serializeDeleted();
     }
-    const rect = this.getPDFRect();
     const color = AnnotationEditor._colorManager.convert(
-      this.isAttachedToDOM ? getComputedStyle(this.editorDiv).color : __privateGet(this, _color2)
+      this.isAttachedToDOM ? getComputedStyle(this.editorDiv).color : this.color
     );
-    const serialized = {
-      annotationType: AnnotationEditorType.FREETEXT,
+    const serialized = Object.assign(super.serialize(isForCopying), {
       color,
       fontSize: __privateGet(this, _fontSize),
-      value: __privateMethod(this, _FreeTextEditor_instances, serializeContent_fn).call(this),
-      pageIndex: this.pageIndex,
-      rect,
-      rotation: this.rotation,
-      structTreeParentId: this._structTreeParentId
-    };
+      value: __privateMethod(this, _FreeTextEditor_instances, serializeContent_fn).call(this)
+    });
     this.addComment(serialized);
     if (isForCopying) {
       serialized.isCopy = true;
@@ -30875,7 +31603,7 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     }
     const { style } = content;
     style.fontSize = `calc(${__privateGet(this, _fontSize)}px * var(--total-scale-factor))`;
-    style.color = __privateGet(this, _color2);
+    style.color = this.color;
     content.replaceChildren();
     for (const line of __privateGet(this, _content).split("\n")) {
       const div = document.createElement("div");
@@ -30884,11 +31612,10 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
       );
       content.append(div);
     }
-    const params = {
-      rect: this.getPDFRect()
-    };
-    params.popup = this.hasEditedComment ? this.comment : { text: __privateGet(this, _content) };
-    annotation.updateEdited(params);
+    annotation.updateEdited({
+      rect: this.getPDFRect(),
+      popup: this._uiManager.hasCommentManager() || this.hasEditedComment ? this.comment : { text: __privateGet(this, _content) }
+    });
     return content;
   }
   resetAnnotationElement(annotation) {
@@ -30896,7 +31623,6 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     annotation.resetEdited();
   }
 };
-_color2 = new WeakMap();
 _content = new WeakMap();
 _editorDivId = new WeakMap();
 _editModeAC = new WeakMap();
@@ -30928,12 +31654,12 @@ updateFontSize_fn = function(fontSize) {
  * Update the color and make this action undoable.
  * @param {string} color
  */
-updateColor_fn = function(color) {
+updateColor_fn2 = function(color) {
   const setColor = (col) => {
-    __privateSet(this, _color2, this.editorDiv.style.color = col);
-    this._colorPicker?.update(col);
+    this.color = col;
+    this.onUpdatedColor();
   };
-  const savedColor = __privateGet(this, _color2);
+  const savedColor = this.color;
   this.addCommands({
     cmd: setColor.bind(this, color),
     undo: setColor.bind(this, savedColor),
@@ -31501,6 +32227,7 @@ var FreeDrawOutline = class extends Outline {
     __privateSet(this, _scaleFactor2, scaleFactor);
     __privateSet(this, _innerMargin2, innerMargin);
     __privateSet(this, _isLTR2, isLTR);
+    this.firstPoint = [NaN, NaN];
     this.lastPoint = [NaN, NaN];
     __privateMethod(this, _FreeDrawOutline_instances, computeMinMax_fn).call(this, isLTR);
     const [x, y, width, height] = __privateGet(this, _bbox);
@@ -31623,13 +32350,22 @@ computeMinMax_fn = function(isLTR) {
   let lastX = outline[4];
   let lastY = outline[5];
   const minMax = [lastX, lastY, lastX, lastY];
+  let firstPointX = lastX;
+  let firstPointY = lastY;
   let lastPointX = lastX;
   let lastPointY = lastY;
   const ltrCallback = isLTR ? Math.max : Math.min;
+  const bezierBbox = new Float32Array(4);
   for (let i = 6, ii = outline.length; i < ii; i += 6) {
     const x = outline[i + 4], y = outline[i + 5];
     if (isNaN(outline[i])) {
       Util.pointBoundingBox(x, y, minMax);
+      if (firstPointY > y) {
+        firstPointX = x;
+        firstPointY = y;
+      } else if (firstPointY === y) {
+        firstPointX = ltrCallback(firstPointX, x);
+      }
       if (lastPointY < y) {
         lastPointX = x;
         lastPointY = y;
@@ -31637,14 +32373,32 @@ computeMinMax_fn = function(isLTR) {
         lastPointX = ltrCallback(lastPointX, x);
       }
     } else {
-      const bbox2 = [Infinity, Infinity, -Infinity, -Infinity];
-      Util.bezierBoundingBox(lastX, lastY, ...outline.slice(i, i + 6), bbox2);
-      Util.rectBoundingBox(...bbox2, minMax);
-      if (lastPointY < bbox2[3]) {
-        lastPointX = bbox2[2];
-        lastPointY = bbox2[3];
-      } else if (lastPointY === bbox2[3]) {
-        lastPointX = ltrCallback(lastPointX, bbox2[2]);
+      bezierBbox[0] = bezierBbox[1] = Infinity;
+      bezierBbox[2] = bezierBbox[3] = -Infinity;
+      Util.bezierBoundingBox(
+        lastX,
+        lastY,
+        ...outline.slice(i, i + 6),
+        bezierBbox
+      );
+      Util.rectBoundingBox(
+        bezierBbox[0],
+        bezierBbox[1],
+        bezierBbox[2],
+        bezierBbox[3],
+        minMax
+      );
+      if (firstPointY > bezierBbox[1]) {
+        firstPointX = bezierBbox[0];
+        firstPointY = bezierBbox[1];
+      } else if (firstPointY === bezierBbox[1]) {
+        firstPointX = ltrCallback(firstPointX, bezierBbox[0]);
+      }
+      if (lastPointY < bezierBbox[3]) {
+        lastPointX = bezierBbox[2];
+        lastPointY = bezierBbox[3];
+      } else if (lastPointY === bezierBbox[3]) {
+        lastPointX = ltrCallback(lastPointX, bezierBbox[2]);
       }
     }
     lastX = x;
@@ -31655,11 +32409,12 @@ computeMinMax_fn = function(isLTR) {
   bbox[1] = minMax[1] - __privateGet(this, _innerMargin2);
   bbox[2] = minMax[2] - minMax[0] + 2 * __privateGet(this, _innerMargin2);
   bbox[3] = minMax[3] - minMax[1] + 2 * __privateGet(this, _innerMargin2);
+  this.firstPoint = [firstPointX, firstPointY];
   this.lastPoint = [lastPointX, lastPointY];
 };
 
 // src/pdf.js/src/display/editor/drawers/highlight.js
-var _box3, _lastPoint, _verticalEdges, _intervals, _HighlightOutliner_instances, getOutlines_fn, binarySearch_fn, insert_fn, remove_fn, breakEdge_fn;
+var _box3, _firstPoint, _lastPoint, _verticalEdges, _intervals, _HighlightOutliner_instances, getOutlines_fn, binarySearch_fn, insert_fn, remove_fn, breakEdge_fn;
 var HighlightOutliner = class {
   /**
    * Construct an outliner.
@@ -31676,6 +32431,7 @@ var HighlightOutliner = class {
   constructor(boxes, borderWidth = 0, innerMargin = 0, isLTR = true) {
     __privateAdd(this, _HighlightOutliner_instances);
     __privateAdd(this, _box3);
+    __privateAdd(this, _firstPoint);
     __privateAdd(this, _lastPoint);
     __privateAdd(this, _verticalEdges, []);
     __privateAdd(this, _intervals, []);
@@ -31696,10 +32452,27 @@ var HighlightOutliner = class {
     const bboxHeight = minMax[3] - minMax[1] + 2 * innerMargin;
     const shiftedMinX = minMax[0] - innerMargin;
     const shiftedMinY = minMax[1] - innerMargin;
+    let firstPointX = isLTR ? -Infinity : Infinity;
+    let firstPointY = Infinity;
     const lastEdge = __privateGet(this, _verticalEdges).at(isLTR ? -1 : -2);
     const lastPoint = [lastEdge[0], lastEdge[2]];
     for (const edge of __privateGet(this, _verticalEdges)) {
-      const [x, y1, y2] = edge;
+      const [x, y1, y2, left] = edge;
+      if (!left && isLTR) {
+        if (y1 < firstPointY) {
+          firstPointY = y1;
+          firstPointX = x;
+        } else if (y1 === firstPointY) {
+          firstPointX = Math.max(firstPointX, x);
+        }
+      } else if (left && !isLTR) {
+        if (y1 < firstPointY) {
+          firstPointY = y1;
+          firstPointX = x;
+        } else if (y1 === firstPointY) {
+          firstPointX = Math.min(firstPointX, x);
+        }
+      }
       edge[0] = (x - shiftedMinX) / bboxWidth;
       edge[1] = (y1 - shiftedMinY) / bboxHeight;
       edge[2] = (y2 - shiftedMinY) / bboxHeight;
@@ -31710,6 +32483,7 @@ var HighlightOutliner = class {
       bboxWidth,
       bboxHeight
     ]));
+    __privateSet(this, _firstPoint, [firstPointX, firstPointY]);
     __privateSet(this, _lastPoint, lastPoint);
   }
   getOutlines() {
@@ -31730,6 +32504,7 @@ var HighlightOutliner = class {
   }
 };
 _box3 = new WeakMap();
+_firstPoint = new WeakMap();
 _lastPoint = new WeakMap();
 _verticalEdges = new WeakMap();
 _intervals = new WeakMap();
@@ -31779,7 +32554,12 @@ getOutlines_fn = function(outlineVerticalEdges) {
     }
     outline.push(lastPointX, lastPointY);
   }
-  return new HighlightOutline(outlines, __privateGet(this, _box3), __privateGet(this, _lastPoint));
+  return new HighlightOutline(
+    outlines,
+    __privateGet(this, _box3),
+    __privateGet(this, _firstPoint),
+    __privateGet(this, _lastPoint)
+  );
 };
 binarySearch_fn = function(y) {
   const array = __privateGet(this, _intervals);
@@ -31860,12 +32640,13 @@ breakEdge_fn = function(edge) {
 };
 var _box4, _outlines;
 var HighlightOutline = class extends Outline {
-  constructor(outlines, box, lastPoint) {
+  constructor(outlines, box, firstPoint, lastPoint) {
     super();
     __privateAdd(this, _box4);
     __privateAdd(this, _outlines);
     __privateSet(this, _outlines, outlines);
     __privateSet(this, _box4, box);
+    this.firstPoint = firstPoint;
     this.lastPoint = lastPoint;
   }
   toSVGPath() {
@@ -31943,7 +32724,7 @@ var FreeHighlightOutline = class extends FreeDrawOutline {
 };
 
 // src/pdf.js/src/display/editor/highlight.js
-var _anchorNode, _anchorOffset, _boxes, _clipPathId, _colorPicker2, _focusOutlines, _focusNode, _focusOffset, _highlightDiv, _highlightOutlines, _id3, _isFreeHighlight, _lastPoint2, _opacity, _outlineId, _text2, _thickness2, _methodOfCreation, _HighlightEditor_instances, createOutlines_fn, createFreeOutlines_fn, updateColor_fn2, updateThickness_fn, changeThickness_fn, cleanDrawLayer_fn, addToDrawLayer_fn, _HighlightEditor_static, rotateBbox_fn, keydown_fn, setCaret_fn, getRotation_fn, serializeBoxes_fn, serializeOutlines_fn, highlightMove_fn, endHighlight_fn, hasElementChanged_fn2;
+var _anchorNode, _anchorOffset, _boxes, _clipPathId, _colorPicker2, _focusOutlines, _focusNode, _focusOffset, _highlightDiv, _highlightOutlines, _id3, _isFreeHighlight, _firstPoint2, _lastPoint2, _outlineId, _text2, _thickness2, _methodOfCreation, _HighlightEditor_instances, createOutlines_fn, createFreeOutlines_fn, updateColor_fn3, updateThickness_fn, changeThickness_fn, cleanDrawLayer_fn, addToDrawLayer_fn, _HighlightEditor_static, rotateBbox_fn, keydown_fn, setCaret_fn, getRotation_fn, serializeBoxes_fn, serializeOutlines_fn, highlightMove_fn, endHighlight_fn, hasElementChanged_fn2;
 var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
   constructor(params) {
     super({ ...params, name: "highlightEditor" });
@@ -31960,15 +32741,15 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     __privateAdd(this, _highlightOutlines, null);
     __privateAdd(this, _id3, null);
     __privateAdd(this, _isFreeHighlight, false);
+    __privateAdd(this, _firstPoint2, null);
     __privateAdd(this, _lastPoint2, null);
-    __privateAdd(this, _opacity);
     __privateAdd(this, _outlineId, null);
     __privateAdd(this, _text2, "");
     __privateAdd(this, _thickness2);
     __privateAdd(this, _methodOfCreation, "");
     this.color = params.color || _HighlightEditor._defaultColor;
     __privateSet(this, _thickness2, params.thickness || _HighlightEditor._defaultThickness);
-    __privateSet(this, _opacity, params.opacity || _HighlightEditor._defaultOpacity);
+    this.opacity = params.opacity || _HighlightEditor._defaultOpacity;
     __privateSet(this, _boxes, params.boxes || null);
     __privateSet(this, _methodOfCreation, params.methodOfCreation || "");
     __privateSet(this, _text2, params.text || "");
@@ -32021,9 +32802,6 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
       color: this._uiManager.getNonHCMColorName(this.color)
     };
   }
-  get commentColor() {
-    return this.color;
-  }
   static computeTelemetryFinalData(data) {
     return { numberOfColors: data.get("color").size };
   }
@@ -32051,10 +32829,14 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     return __privateGet(this, _lastPoint2);
   }
   /** @inheritdoc */
+  get commentButtonPosition() {
+    return __privateGet(this, _firstPoint2);
+  }
+  /** @inheritdoc */
   updateParams(type, value) {
     switch (type) {
       case AnnotationEditorParamsType.HIGHLIGHT_COLOR:
-        __privateMethod(this, _HighlightEditor_instances, updateColor_fn2).call(this, value);
+        __privateMethod(this, _HighlightEditor_instances, updateColor_fn3).call(this, value);
         break;
       case AnnotationEditorParamsType.HIGHLIGHT_THICKNESS:
         __privateMethod(this, _HighlightEditor_instances, updateThickness_fn).call(this, value);
@@ -32088,6 +32870,17 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     ];
   }
   /** @inheritdoc */
+  onUpdatedColor() {
+    this.parent?.drawLayer.updateProperties(__privateGet(this, _id3), {
+      root: {
+        fill: this.color,
+        "fill-opacity": this.opacity
+      }
+    });
+    __privateGet(this, _colorPicker2)?.updateColor(this.color);
+    super.onUpdatedColor();
+  }
+  /** @inheritdoc */
   get toolbarButtons() {
     if (this._uiManager.highlightColors) {
       const colorPicker = __privateSet(this, _colorPicker2, new ColorPicker({
@@ -32210,8 +33003,7 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     highlightDiv.setAttribute("aria-hidden", "true");
     highlightDiv.className = "internal";
     highlightDiv.style.clipPath = __privateGet(this, _clipPathId);
-    const [parentWidth, parentHeight] = this.parentDimensions;
-    this.setDims(this.width * parentWidth, this.height * parentHeight);
+    this.setDims(this.width, this.height);
     bindEvents(this, __privateGet(this, _highlightDiv), ["pointerover", "pointerleave"]);
     this.enableEditing();
     return div;
@@ -32382,7 +33174,10 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
           color: color2,
           opacity: opacity2,
           popupRef,
-          contentsObj
+          richText,
+          contentsObj,
+          creationDate,
+          modificationDate
         },
         parent: {
           page: { pageNumber }
@@ -32401,7 +33196,10 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
         id: id2,
         deleted: false,
         popupRef,
-        comment: contentsObj?.str || null
+        richText,
+        comment: contentsObj?.str || null,
+        creationDate,
+        modificationDate
       };
     } else if (data instanceof InkAnnotationElement) {
       const {
@@ -32413,7 +33211,10 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
           color: color2,
           borderStyle: { rawWidth: thickness },
           popupRef,
-          contentsObj
+          richText,
+          contentsObj,
+          creationDate,
+          modificationDate
         },
         parent: {
           page: { pageNumber }
@@ -32432,19 +33233,22 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
         id: id2,
         deleted: false,
         popupRef,
-        comment: contentsObj?.str || null
+        richText,
+        comment: contentsObj?.str || null,
+        creationDate,
+        modificationDate
       };
     }
     const { color, quadPoints, inkLists, opacity } = data;
     const editor = await super.deserialize(data, parent, uiManager);
     editor.color = Util.makeHexColor(...color);
-    __privateSet(editor, _opacity, opacity || 1);
+    editor.opacity = opacity || 1;
     if (inkLists) {
       __privateSet(editor, _thickness2, data.thickness);
     }
     editor._initialData = initialData;
     if (data.comment) {
-      editor.setCommentData(data.comment);
+      editor.setCommentData(data);
     }
     const [pageWidth, pageHeight] = editor.pageDimensions;
     const [pageX, pageY] = editor.pageTranslation;
@@ -32520,22 +33324,17 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     if (this.deleted) {
       return this.serializeDeleted();
     }
-    const rect = this.getPDFRect();
     const color = AnnotationEditor._colorManager.convert(
       this._uiManager.getNonHCMColor(this.color)
     );
-    const serialized = {
-      annotationType: AnnotationEditorType.HIGHLIGHT,
+    const serialized = super.serialize(isForCopying);
+    Object.assign(serialized, {
       color,
-      opacity: __privateGet(this, _opacity),
+      opacity: this.opacity,
       thickness: __privateGet(this, _thickness2),
       quadPoints: __privateMethod(this, _HighlightEditor_instances, serializeBoxes_fn).call(this),
-      outlines: __privateMethod(this, _HighlightEditor_instances, serializeOutlines_fn).call(this, rect),
-      pageIndex: this.pageIndex,
-      rect,
-      rotation: __privateMethod(this, _HighlightEditor_instances, getRotation_fn).call(this),
-      structTreeParentId: this._structTreeParentId
-    };
+      outlines: __privateMethod(this, _HighlightEditor_instances, serializeOutlines_fn).call(this, serialized.rect)
+    });
     this.addComment(serialized);
     if (this.annotationElementId && !__privateMethod(this, _HighlightEditor_instances, hasElementChanged_fn2).call(this, serialized)) {
       return null;
@@ -32549,13 +33348,10 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
       annotation.hide();
       return null;
     }
-    const params = {
-      rect: this.getPDFRect()
-    };
-    if (this.hasEditedComment) {
-      params.popup = this.comment;
-    }
-    annotation.updateEdited(params);
+    annotation.updateEdited({
+      rect: this.getPDFRect(),
+      popup: this.comment
+    });
     return null;
   }
   static canCreateNewEmptyEditor() {
@@ -32574,8 +33370,8 @@ _highlightDiv = new WeakMap();
 _highlightOutlines = new WeakMap();
 _id3 = new WeakMap();
 _isFreeHighlight = new WeakMap();
+_firstPoint2 = new WeakMap();
 _lastPoint2 = new WeakMap();
-_opacity = new WeakMap();
 _outlineId = new WeakMap();
 _text2 = new WeakMap();
 _thickness2 = new WeakMap();
@@ -32598,6 +33394,11 @@ createOutlines_fn = function() {
     this._uiManager.direction === "ltr"
   );
   __privateSet(this, _focusOutlines, outlinerForOutline.getOutlines());
+  const { firstPoint } = __privateGet(this, _highlightOutlines);
+  __privateSet(this, _firstPoint2, [
+    (firstPoint[0] - this.x) / this.width,
+    (firstPoint[1] - this.y) / this.height
+  ]);
   const { lastPoint } = __privateGet(this, _focusOutlines);
   __privateSet(this, _lastPoint2, [
     (lastPoint[0] - this.x) / this.width,
@@ -32684,6 +33485,11 @@ createFreeOutlines_fn = function({ highlightOutlines, highlightId, clipPathId })
       break;
     }
   }
+  const { firstPoint } = highlightOutlines;
+  __privateSet(this, _firstPoint2, [
+    (firstPoint[0] - x) / width,
+    (firstPoint[1] - y) / height
+  ]);
   const { lastPoint } = __privateGet(this, _focusOutlines);
   __privateSet(this, _lastPoint2, [(lastPoint[0] - x) / width, (lastPoint[1] - y) / height]);
 };
@@ -32691,20 +33497,14 @@ createFreeOutlines_fn = function({ highlightOutlines, highlightId, clipPathId })
  * Update the color and make this action undoable.
  * @param {string} color
  */
-updateColor_fn2 = function(color) {
+updateColor_fn3 = function(color) {
   const setColorAndOpacity = (col, opa) => {
     this.color = col;
-    __privateSet(this, _opacity, opa);
-    this.parent?.drawLayer.updateProperties(__privateGet(this, _id3), {
-      root: {
-        fill: col,
-        "fill-opacity": opa
-      }
-    });
-    __privateGet(this, _colorPicker2)?.updateColor(col);
+    this.opacity = opa;
+    this.onUpdatedColor();
   };
   const savedColor = this.color;
-  const savedOpacity = __privateGet(this, _opacity);
+  const savedOpacity = this.opacity;
   this.addCommands({
     cmd: setColorAndOpacity.bind(
       this,
@@ -32760,8 +33560,7 @@ changeThickness_fn = function(thickness) {
     highlightOutlines: __privateGet(this, _highlightOutlines).getNewOutline(thickness / 2)
   });
   this.fixAndSetPosition();
-  const [parentWidth, parentHeight] = this.parentDimensions;
-  this.setDims(this.width * parentWidth, this.height * parentHeight);
+  this.setDims(this.width, this.height);
 };
 cleanDrawLayer_fn = function() {
   if (__privateGet(this, _id3) === null || !this.parent) {
@@ -32782,7 +33581,7 @@ addToDrawLayer_fn = function(parent = this.parent) {
       root: {
         viewBox: "0 0 1 1",
         fill: this.color,
-        "fill-opacity": __privateGet(this, _opacity)
+        "fill-opacity": this.opacity
       },
       rootClass: {
         highlight: true,
@@ -32957,6 +33756,11 @@ var _DrawingEditor = class _DrawingEditor extends AnnotationEditor {
     __privateSet(this, _mustBeCommitted, params.mustBeCommitted || false);
     this._addOutlines(params);
   }
+  /** @inheritdoc */
+  onUpdatedColor() {
+    this._colorPicker?.update(this.color);
+    super.onUpdatedColor();
+  }
   _addOutlines(params) {
     if (params.drawOutlines) {
       __privateMethod(this, _DrawingEditor_instances, createDrawOutlines_fn).call(this, params);
@@ -33056,7 +33860,7 @@ var _DrawingEditor = class _DrawingEditor extends AnnotationEditor {
         options.toSVGProperties()
       );
       if (type === this.colorType) {
-        this._colorPicker?.update(val);
+        this.onUpdatedColor();
       }
     };
     this.addCommands({
@@ -33250,8 +34054,7 @@ var _DrawingEditor = class _DrawingEditor extends AnnotationEditor {
     div.append(drawDiv);
     drawDiv.setAttribute("aria-hidden", "true");
     drawDiv.className = "internal";
-    const [parentWidth, parentHeight] = this.parentDimensions;
-    this.setDims(this.width * parentWidth, this.height * parentHeight);
+    this.setDims();
     this._uiManager.addShouldRescale(this);
     this.disableEditing();
     if (this._isCopy) {
@@ -33645,8 +34448,7 @@ updateBbox_fn = function(bbox) {
   [this.x, this.y, this.width, this.height] = __privateMethod(this, _DrawingEditor_instances, convertToParentSpace_fn).call(this, bbox);
   if (this.div) {
     this.fixAndSetPosition();
-    const [parentWidth, parentHeight] = this.parentDimensions;
-    this.setDims(this.width * parentWidth, this.height * parentHeight);
+    this.setDims();
   }
   this._onResized();
 };
@@ -34573,7 +35375,10 @@ var _InkEditor = class _InkEditor extends DrawingEditor {
           opacity,
           borderStyle: { rawWidth: thickness },
           popupRef,
-          contentsObj
+          richText,
+          contentsObj,
+          creationDate,
+          modificationDate
         },
         parent: {
           page: { pageNumber }
@@ -34593,13 +35398,16 @@ var _InkEditor = class _InkEditor extends DrawingEditor {
         id: id2,
         deleted: false,
         popupRef,
-        comment: contentsObj?.str || null
+        richText,
+        comment: contentsObj?.str || null,
+        creationDate,
+        modificationDate
       };
     }
     const editor = await super.deserialize(data, parent, uiManager);
     editor._initialData = initialData;
     if (data.comment) {
-      editor.setCommentData(data.comment);
+      editor.setCommentData(data);
     }
     return editor;
   }
@@ -34611,9 +35419,12 @@ var _InkEditor = class _InkEditor extends DrawingEditor {
   get colorType() {
     return AnnotationEditorParamsType.INK_COLOR;
   }
-  get colorValue() {
+  get color() {
     return this._drawingOptions.stroke;
   }
+  get opacity() {
+    return this._drawingOptions["stroke-opacity"];
+  }
   /** @inheritdoc */
   onScaleChanging() {
     if (!this.parent) {
@@ -34655,7 +35466,7 @@ var _InkEditor = class _InkEditor extends DrawingEditor {
     if (this.deleted) {
       return this.serializeDeleted();
     }
-    const { lines, points, rect } = this.serializeDraw(isForCopying);
+    const { lines, points } = this.serializeDraw(isForCopying);
     const {
       _drawingOptions: {
         stroke,
@@ -34663,20 +35474,15 @@ var _InkEditor = class _InkEditor extends DrawingEditor {
         "stroke-width": thickness
       }
     } = this;
-    const serialized = {
-      annotationType: AnnotationEditorType.INK,
+    const serialized = Object.assign(super.serialize(isForCopying), {
       color: AnnotationEditor._colorManager.convert(stroke),
       opacity,
       thickness,
       paths: {
         lines,
         points
-      },
-      pageIndex: this.pageIndex,
-      rect,
-      rotation: this.rotation,
-      structTreeParentId: this._structTreeParentId
-    };
+      }
+    });
     this.addComment(serialized);
     if (isForCopying) {
       serialized.isCopy = true;
@@ -34698,15 +35504,12 @@ var _InkEditor = class _InkEditor extends DrawingEditor {
       /* isForCopying = */
       false
     );
-    const params = {
+    annotation.updateEdited({
       rect,
       thickness: this._drawingOptions["stroke-width"],
-      points
-    };
-    if (this.hasEditedComment) {
-      params.popup = this.comment;
-    }
-    annotation.updateEdited(params);
+      points,
+      popup: this.comment
+    });
     return null;
   }
 };
@@ -35582,7 +36385,6 @@ var _SignatureEditor = class _SignatureEditor extends DrawingEditor {
       drawOutlines: outline,
       drawingOptions
     });
-    const [parentWidth, parentHeight] = this.parentDimensions;
     const [, pageHeight] = this.pageDimensions;
     let newHeight = heightInPage / pageHeight;
     newHeight = newHeight >= 1 ? 0.5 : newHeight;
@@ -35592,7 +36394,7 @@ var _SignatureEditor = class _SignatureEditor extends DrawingEditor {
       this.width = 0.9;
     }
     this.height = newHeight;
-    this.setDims(parentWidth * this.width, parentHeight * this.height);
+    this.setDims();
     this.x = savedX;
     this.y = savedY;
     this.center();
@@ -35666,21 +36468,16 @@ var _SignatureEditor = class _SignatureEditor extends DrawingEditor {
     if (this.isEmpty()) {
       return null;
     }
-    const { lines, points, rect } = this.serializeDraw(isForCopying);
+    const { lines, points } = this.serializeDraw(isForCopying);
     const {
       _drawingOptions: { "stroke-width": thickness }
     } = this;
-    const serialized = {
-      annotationType: AnnotationEditorType.SIGNATURE,
+    const serialized = Object.assign(super.serialize(isForCopying), {
       isSignature: true,
       areContours: __privateGet(this, _isExtracted),
       color: [0, 0, 0],
-      thickness: __privateGet(this, _isExtracted) ? 0 : thickness,
-      pageIndex: this.pageIndex,
-      rect,
-      rotation: this.rotation,
-      structTreeParentId: this._structTreeParentId
-    };
+      thickness: __privateGet(this, _isExtracted) ? 0 : thickness
+    });
     this.addComment(serialized);
     if (isForCopying) {
       serialized.paths = { lines, points };
@@ -35974,7 +36771,7 @@ var StampEditor = class extends AnnotationEditor {
       let white = "white", black = "#cfcfd8";
       if (this._uiManager.hcmFilter !== "none") {
         black = "black";
-      } else if (window.matchMedia?.("(prefers-color-scheme: dark)").matches) {
+      } else if (ColorScheme.isDarkMode) {
         white = "#8f8f9d";
         black = "#42414d";
       }
@@ -36051,7 +36848,17 @@ var StampEditor = class extends AnnotationEditor {
     let missingCanvas = false;
     if (data instanceof StampAnnotationElement) {
       const {
-        data: { rect: rect2, rotation, id: id2, structParent, popupRef, contentsObj },
+        data: {
+          rect: rect2,
+          rotation,
+          id: id2,
+          structParent,
+          popupRef,
+          richText,
+          contentsObj,
+          creationDate,
+          modificationDate
+        },
         container,
         parent: {
           page: { pageNumber }
@@ -36088,7 +36895,10 @@ var StampEditor = class extends AnnotationEditor {
         isSvg: false,
         structParent,
         popupRef,
-        comment: contentsObj?.str || null
+        richText,
+        comment: contentsObj?.str || null,
+        creationDate,
+        modificationDate
       };
     }
     const editor = await super.deserialize(data, parent, uiManager);
@@ -36113,7 +36923,7 @@ var StampEditor = class extends AnnotationEditor {
     }
     editor._initialData = initialData;
     if (data.comment) {
-      editor.setCommentData(data.comment);
+      editor.setCommentData(data);
     }
     __privateSet(editor, _hasBeenAddedInUndoStack, !!initialData);
     return editor;
@@ -36126,15 +36936,10 @@ var StampEditor = class extends AnnotationEditor {
     if (this.deleted) {
       return this.serializeDeleted();
     }
-    const serialized = {
-      annotationType: AnnotationEditorType.STAMP,
+    const serialized = Object.assign(super.serialize(isForCopying), {
       bitmapId: __privateGet(this, _bitmapId),
-      pageIndex: this.pageIndex,
-      rect: this.getPDFRect(),
-      rotation: this.rotation,
-      isSvg: __privateGet(this, _isSvg),
-      structTreeParentId: this._structTreeParentId
-    };
+      isSvg: __privateGet(this, _isSvg)
+    });
     this.addComment(serialized);
     if (isForCopying) {
       serialized.bitmapUrl = __privateMethod(this, _StampEditor_instances, serializeBitmap_fn).call(
@@ -36160,8 +36965,10 @@ var StampEditor = class extends AnnotationEditor {
       } else {
         serialized.accessibilityData.structParent = this._initialData.structParent ?? -1;
       }
+      serialized.id = this.annotationElementId;
+      delete serialized.bitmapId;
+      return serialized;
     }
-    serialized.id = this.annotationElementId;
     if (context === null) {
       return serialized;
     }
@@ -36194,13 +37001,10 @@ var StampEditor = class extends AnnotationEditor {
       annotation.hide();
       return null;
     }
-    const params = {
-      rect: this.getPDFRect()
-    };
-    if (this.hasEditedComment) {
-      params.popup = this.comment;
-    }
-    annotation.updateEdited(params);
+    annotation.updateEdited({
+      rect: this.getPDFRect(),
+      popup: this.comment
+    });
     return null;
   }
 };
@@ -36347,17 +37151,13 @@ createCanvas_fn = function() {
     width *= factor;
     height *= factor;
   }
-  const [parentWidth, parentHeight] = this.parentDimensions;
-  this.setDims(
-    width * parentWidth / pageWidth,
-    height * parentHeight / pageHeight
-  );
   this._uiManager.enableWaiting(false);
   const canvas = __privateSet(this, _canvas, document.createElement("canvas"));
   canvas.setAttribute("role", "img");
   this.addContainer(canvas);
   this.width = width / pageWidth;
   this.height = height / pageHeight;
+  this.setDims();
   if (this._initialOptions?.isCentered) {
     this.center();
   } else {
@@ -36495,7 +37295,7 @@ __publicField(StampEditor, "_type", "stamp");
 __publicField(StampEditor, "_editorType", AnnotationEditorType.STAMP);
 
 // src/pdf.js/src/display/editor/annotation_editor_layer.js
-var _accessibilityManager2, _allowClick, _annotationLayer, _clickAC, _editorFocusTimeoutId, _editors, _hadPointerDown, _isDisabling, _isEnabling, _drawingAC, _focusedElement, _textLayer, _textSelectionAC, _textLayerDblClickAC, _lastPointerDownTimestamp, _uiManager4, _editorTypes2, _AnnotationEditorLayer_instances, textLayerPointerDown_fn, currentEditorType_get, createNewEditor_fn, getCenterPoint_fn, cleanup_fn;
+var _accessibilityManager2, _allowClick, _annotationLayer, _clickAC, _editorFocusTimeoutId, _editors, _hadPointerDown, _isDisabling, _isEnabling, _drawingAC, _focusedElement, _textLayer, _textSelectionAC, _textLayerDblClickAC, _lastPointerDownTimestamp, _uiManager4, _editorTypes2, _AnnotationEditorLayer_instances, allEditorsIterator_get, textLayerPointerDown_fn, currentEditorType_get, createNewEditor_fn, getCenterPoint_fn, cleanup_fn;
 var _AnnotationEditorLayer = class _AnnotationEditorLayer {
   /**
    * @param {AnnotationEditorLayerOptions} options
@@ -36569,6 +37369,7 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
     __privateMethod(this, _AnnotationEditorLayer_instances, cleanup_fn).call(this);
     switch (mode) {
       case AnnotationEditorType.NONE:
+        this.div.classList.toggle("nonEditing", true);
         this.disableTextSelection();
         this.togglePointerEvents(false);
         this.toggleAnnotationLayerPointerEvents(true);
@@ -36591,11 +37392,17 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
     }
     this.toggleAnnotationLayerPointerEvents(false);
     const { classList } = this.div;
-    for (const editorType of __privateGet(_AnnotationEditorLayer, _editorTypes2).values()) {
-      classList.toggle(
-        `${editorType._type}Editing`,
-        mode === editorType._editorType
-      );
+    classList.toggle("nonEditing", false);
+    if (mode === AnnotationEditorType.POPUP) {
+      classList.toggle("commentEditing", true);
+    } else {
+      classList.toggle("commentEditing", false);
+      for (const editorType of __privateGet(_AnnotationEditorLayer, _editorTypes2).values()) {
+        classList.toggle(
+          `${editorType._type}Editing`,
+          mode === editorType._editorType
+        );
+      }
     }
     this.div.hidden = false;
   }
@@ -36636,10 +37443,11 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
     __privateSet(this, _isEnabling, true);
     this.div.tabIndex = 0;
     this.togglePointerEvents(true);
+    this.div.classList.toggle("nonEditing", false);
     __privateGet(this, _textLayerDblClickAC)?.abort();
     __privateSet(this, _textLayerDblClickAC, null);
     const annotationElementIds = /* @__PURE__ */ new Set();
-    for (const editor of __privateGet(this, _editors).values()) {
+    for (const editor of __privateGet(this, _AnnotationEditorLayer_instances, allEditorsIterator_get)) {
       editor.enableEditing();
       editor.show(true);
       if (editor.annotationElementId) {
@@ -36647,27 +37455,29 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
         annotationElementIds.add(editor.annotationElementId);
       }
     }
-    if (!__privateGet(this, _annotationLayer)) {
-      __privateSet(this, _isEnabling, false);
-      return;
-    }
-    const editables = __privateGet(this, _annotationLayer).getEditableAnnotations();
-    for (const editable of editables) {
-      editable.hide();
-      if (__privateGet(this, _uiManager4).isDeletedAnnotationElement(editable.data.id)) {
-        continue;
-      }
-      if (annotationElementIds.has(editable.data.id)) {
-        continue;
-      }
-      const editor = await this.deserialize(editable);
-      if (!editor) {
-        continue;
+    const annotationLayer = __privateGet(this, _annotationLayer);
+    if (annotationLayer) {
+      for (const editable of annotationLayer.getEditableAnnotations()) {
+        editable.hide();
+        if (__privateGet(this, _uiManager4).isDeletedAnnotationElement(editable.data.id)) {
+          continue;
+        }
+        if (annotationElementIds.has(editable.data.id)) {
+          continue;
+        }
+        const editor = await this.deserialize(editable);
+        if (!editor) {
+          continue;
+        }
+        this.addOrRebuild(editor);
+        editor.enableEditing();
       }
-      this.addOrRebuild(editor);
-      editor.enableEditing();
     }
     __privateSet(this, _isEnabling, false);
+    __privateGet(this, _uiManager4)._eventBus.dispatch("editorsrendered", {
+      source: this,
+      pageNumber: this.pageIndex + 1
+    });
   }
   /**
    * Disable editor creation.
@@ -36676,6 +37486,7 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
     __privateSet(this, _isDisabling, true);
     this.div.tabIndex = -1;
     this.togglePointerEvents(false);
+    this.div.classList.toggle("nonEditing", true);
     if (__privateGet(this, _textLayer) && !__privateGet(this, _textLayerDblClickAC)) {
       __privateSet(this, _textLayerDblClickAC, new AbortController());
       const signal = __privateGet(this, _uiManager4).combinedSignal(__privateGet(this, _textLayerDblClickAC));
@@ -36712,30 +37523,32 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
           if (editor?.annotationElementId === null) {
             e.stopPropagation();
             e.preventDefault();
-            editor.dblclick();
+            editor.dblclick(e);
           }
         },
         { signal, capture: true }
       );
     }
-    const changedAnnotations = /* @__PURE__ */ new Map();
-    const resetAnnotations = /* @__PURE__ */ new Map();
-    for (const editor of __privateGet(this, _editors).values()) {
-      editor.disableEditing();
-      if (!editor.annotationElementId) {
-        continue;
-      }
-      if (editor.serialize() !== null) {
-        changedAnnotations.set(editor.annotationElementId, editor);
-        continue;
-      } else {
-        resetAnnotations.set(editor.annotationElementId, editor);
+    const annotationLayer = __privateGet(this, _annotationLayer);
+    if (annotationLayer) {
+      const changedAnnotations = /* @__PURE__ */ new Map();
+      const resetAnnotations = /* @__PURE__ */ new Map();
+      for (const editor of __privateGet(this, _AnnotationEditorLayer_instances, allEditorsIterator_get)) {
+        editor.disableEditing();
+        if (!editor.annotationElementId) {
+          editor.updateFakeAnnotationElement(annotationLayer);
+          continue;
+        }
+        if (editor.serialize() !== null) {
+          changedAnnotations.set(editor.annotationElementId, editor);
+          continue;
+        } else {
+          resetAnnotations.set(editor.annotationElementId, editor);
+        }
+        this.getEditableAnnotation(editor.annotationElementId)?.show();
+        editor.remove();
       }
-      this.getEditableAnnotation(editor.annotationElementId)?.show();
-      editor.remove();
-    }
-    if (__privateGet(this, _annotationLayer)) {
-      const editables = __privateGet(this, _annotationLayer).getEditableAnnotations();
+      const editables = annotationLayer.getEditableAnnotations();
       for (const editable of editables) {
         const { id: id2 } = editable.data;
         if (__privateGet(this, _uiManager4).isDeletedAnnotationElement(id2)) {
@@ -36948,6 +37761,14 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
     };
     this.addCommands({ cmd, undo, mustExec: false });
   }
+  getEditorByUID(uid) {
+    for (const editor of __privateGet(this, _editors).values()) {
+      if (editor.uid === uid) {
+        return editor;
+      }
+    }
+    return null;
+  }
   /**
    * Get an id for an editor.
    * @returns {string}
@@ -36987,7 +37808,7 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
   /**
    * Create a new editor
    * @param {Object} data
-   * @returns {AnnotationEditor | null}
+   * @returns {Promise<AnnotationEditor | null>}
    */
   async deserialize(data) {
     return await __privateGet(_AnnotationEditorLayer, _editorTypes2).get(data.annotationType ?? data.annotationEditorType)?.deserialize(data, this, __privateGet(this, _uiManager4)) || null;
@@ -37015,6 +37836,9 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
     }
     return editor;
   }
+  get boundingClientRect() {
+    return this.div.getBoundingClientRect();
+  }
   /**
    * Create and add a new editor.
    */
@@ -37267,6 +38091,9 @@ _lastPointerDownTimestamp = new WeakMap();
 _uiManager4 = new WeakMap();
 _editorTypes2 = new WeakMap();
 _AnnotationEditorLayer_instances = new WeakSet();
+allEditorsIterator_get = function() {
+  return __privateGet(this, _editors).size !== 0 ? __privateGet(this, _editors).values() : __privateGet(this, _uiManager4).getEditors(this.pageIndex);
+};
 textLayerPointerDown_fn = function(event) {
   __privateGet(this, _uiManager4).unselectAll();
   const { target } = event;
@@ -37312,7 +38139,7 @@ createNewEditor_fn = function(params) {
   return editorType ? new editorType.prototype.constructor(params) : null;
 };
 getCenterPoint_fn = function() {
-  const { x, y, width, height } = this.div.getBoundingClientRect();
+  const { x, y, width, height } = this.boundingClientRect;
   const tlX = Math.max(0, x);
   const tlY = Math.max(0, y);
   const brX = Math.min(window.innerWidth, x + width);
@@ -37559,13 +38386,16 @@ globalThis.pdfjsLib = {
   AnnotationLayer,
   AnnotationMode,
   AnnotationType,
+  applyOpacity,
   build,
   ColorPicker,
   createValidAbsoluteUrl,
+  CSSConstants,
   DOMSVGFactory,
   DrawLayer,
   FeatureTest,
   fetchData,
+  findContrastColor,
   getDocument,
   getFilenameFromUrl,
   getPdfFilenameFromUrl,
@@ -37590,6 +38420,7 @@ globalThis.pdfjsLib = {
   PermissionFlag,
   PixelsPerInch,
   RenderingCancelledException,
+  renderRichText,
   ResponseException,
   setLayerDimensions,
   shadow,
@@ -39003,7 +39834,7 @@ function destroySvgContext(ctx) {
 
 // src/lib/PDFPageProxy.ts
 async function loadNodeCanvasFactory() {
-  const { NodeCanvasFactory: NodeCanvasFactory2 } = await import("./NodeUtils-ZPPZPJWD.js");
+  const { NodeCanvasFactory: NodeCanvasFactory2 } = await import("./NodeUtils-PVXQMWFJ.js");
   return new NodeCanvasFactory2({});
 }
 var getAnnotations = PDFPageProxy.prototype.getAnnotations;
@@ -39392,6 +40223,94 @@ var MAX_TEXT_DIVS_TO_RENDER2 = 1e5;
 var DEFAULT_FONT_SIZE3 = 30;
 var DEFAULT_FONT_ASCENT = 0.8;
 var HYPHEN_REGEX = /-\n+$/;
+var renderTextLayer = (root, options = {}) => {
+  const { classes = false, styles = false } = options;
+  const serializeAttributes = (attrs) => {
+    return Object.entries(attrs).filter(([_, value]) => value != null).map(([key, value]) => `${key}="${value}"`).join(" ");
+  };
+  const serializeStyles = (styles2) => {
+    return Object.entries(styles2).filter(([_, value]) => value != null).map(([key, value]) => `${key}: ${value};`).join(" ");
+  };
+  const internalRenderNode = (node, parents = []) => {
+    if (typeof node === "string") {
+      return node;
+    }
+    if (isTextNode(node)) {
+      const isHeading = parents.find((p) => p.role.match(/^h[1-6]$/));
+      const tag2 = isHeading ? "span" : node.fontWeight >= 700 ? "strong" : node.fontStyle === "italic" ? "em" : "span";
+      const serializedAttrs2 = serializeAttributes(
+        classes ? {
+          class: "tl-text"
+        } : {}
+      );
+      const serializedStyle = styles ? serializeStyles({
+        "--tl-left": `${node.left}px`,
+        "--tl-top": `${node.top}px`,
+        "--tl-font-size": `${node.fontSize}px`,
+        "--tl-font-style": node.fontStyle,
+        "--tl-font-weight": node.fontWeight,
+        "--tl-transform": [
+          typeof node.scale === "number" && node.scale !== 1 ? `scaleX(${node.scale})` : null,
+          typeof node.angle === "number" && node.angle !== 0 ? `rotate(${node.angle}deg)` : null
+        ].filter((v) => v !== null).join(" ")
+      }) : "";
+      let contents;
+      if (typeof node.text === "string") {
+        contents = node.text;
+      } else {
+        contents = node.text.map((chunk) => {
+          const tag3 = !isHeading && node.fontWeight >= 700 && node.fontStyle === "italic";
+          const serializedAttrs3 = serializeAttributes(
+            classes ? {
+              class: "tl-span"
+            } : {}
+          );
+          const serializedStyle2 = styles ? serializeStyles({
+            "--tl-left": `${chunk.left}px`,
+            "--tl-top": `${chunk.top}px`,
+            "--tl-transform": typeof chunk.scale === "number" && chunk.scale !== 1 ? `scaleX(${chunk.scale ?? 1})` : null
+          }) : "";
+          return `<${tag3}${serializedAttrs3 ? ` ${serializedAttrs3}` : ""}${serializedStyle2 ? ` style="${serializedStyle2}` : ""}">${chunk.text}</${tag3}>`;
+        }).join("");
+      }
+      return `<${tag2}${serializedAttrs2 ? ` ${serializedAttrs2}` : ""}${serializedStyle ? ` style="${serializedStyle}"` : ""}>${contents}</${tag2}>`;
+    }
+    if (isAnchorNode(node)) {
+      return `<a href="${node.href}" target="_blank" rel="noopener noreferrer nofollow">
+	${node.children.map((child) => internalRenderNode(child, [...parents, node])).join("")}
+</a>`;
+    }
+    const attrs = {};
+    if (classes) {
+      if (isElementNode(node)) {
+        attrs.class = "tl-element";
+      } else {
+        attrs.class = "tl-node";
+      }
+    }
+    switch (node.role) {
+      case "th":
+      case "td": {
+        if (node.attrs?.ColSpan) {
+          attrs.colspan = node.attrs.ColSpan;
+        }
+        if (node.attrs?.RowSpan) {
+          attrs.rowspan = node.attrs.RowSpan;
+        }
+        break;
+      }
+    }
+    const tag = node.role === "root" ? "article" : node.role;
+    const serializedAttrs = serializeAttributes(attrs);
+    if (!isElementNode(node)) {
+      return `<${tag}${serializedAttrs ? ` ${serializedAttrs}` : ""}></${tag}>`;
+    }
+    return `<${tag}${serializedAttrs ? ` ${serializedAttrs}` : ""}>
+	${node.children.map((child) => internalRenderNode(child, [...parents, node])).join("")}
+</${tag}>`;
+  };
+  return internalRenderNode(root);
+};
 var decorateStructTree = (node, rootContainer, graphics, annotations, parents = []) => {
   let parent = parents.at(-1) || rootContainer;
   if ("role" in node) {
@@ -39896,7 +40815,7 @@ var WasmFactory = class {
   }) {
     switch (filename) {
       case "openjpeg.wasm":
-        return import("./openjpeg-TRZ4ANDN.js").then(
+        return import("./openjpeg-QFJSFVSJ.js").then(
           (module) => module.default
         );
       case "qcms_bg":
@@ -40359,6 +41278,7 @@ export {
   AnnotationLayer,
   AnnotationMode,
   AnnotationType,
+  CSSConstants,
   ColorPicker,
   DOMSVGFactory,
   DrawLayer,
@@ -40389,6 +41309,7 @@ export {
   VerbosityLevel,
   WasmFactory,
   XfaLayer,
+  applyOpacity,
   build,
   canvasToData,
   colorToRgb,
@@ -40399,6 +41320,7 @@ export {
   createValidAbsoluteUrl,
   destroySvgContext,
   fetchData,
+  findContrastColor,
   getDocument,
   getFilenameFromUrl,
   getPdfFilenameFromUrl,
@@ -40452,7 +41374,9 @@ export {
   noContextMenu,
   normalizeUnicode,
   parseRgbaColor,
+  renderRichText,
   renderSvgNode,
+  renderTextLayer,
   rgbToHex,
   setLayerDimensions,
   shadow,