@embedpdf/plugin-annotation 2.7.0 → 2.9.0

package/dist/index.js

@@ -156,8 +156,11 @@ function isLink(a) {
 function isRedact(a) {
   return a.object.type === PdfAnnotationSubtype.REDACT;
 }
+function isCaret(a) {
+  return a.object.type === PdfAnnotationSubtype.CARET;
+}
 function isSidebarAnnotation(a) {
-  return isTextMarkup(a) || isInk(a) || isSquare(a) || isCircle(a) || isPolygon(a) || isLine(a) || isPolyline(a) || isFreeText(a) || isStamp(a) || isRedact(a);
+  return isText(a) && !a.object.inReplyToId || isTextMarkup(a) || isInk(a) || isSquare(a) || isCircle(a) || isPolygon(a) || isLine(a) || isPolyline(a) || isFreeText(a) || isStamp(a) || isRedact(a) || isCaret(a);
 }
 const getAnnotationsByPageIndex = (s, page) => (s.pages[page] ?? []).map((uid) => s.byUid[uid]);
 const getAnnotations = (s) => {
@@ -199,19 +202,33 @@ const getSidebarAnnotationsWithRepliesGroupedByPage = (s) => {
       }
     }
   }
+  const membersByLeader = {};
+  const consumedAsGroupMember = /* @__PURE__ */ new Set();
+  for (const uidList of Object.values(s.pages)) {
+    for (const uid of uidList) {
+      const ta = s.byUid[uid];
+      if (ta && ta.object.inReplyToId && ta.object.replyType === PdfAnnotationReplyType.Group && ta.object.type !== PdfAnnotationSubtype.LINK && isSidebarAnnotation(ta)) {
+        const leaderId = ta.object.inReplyToId;
+        (membersByLeader[leaderId] || (membersByLeader[leaderId] = [])).push(ta);
+        consumedAsGroupMember.add(ta.object.id);
+      }
+    }
+  }
   const out = {};
   for (const [pageStr, uidList] of Object.entries(s.pages)) {
     const page = Number(pageStr);
     const pageAnnotations = [];
     for (const uid of uidList) {
       const ta = s.byUid[uid];
-      if (ta && isSidebarAnnotation(ta)) {
-        pageAnnotations.push({
-          page,
-          annotation: ta,
-          replies: repliesByParent[ta.object.id] ?? []
-        });
-      }
+      if (!ta || !isSidebarAnnotation(ta)) continue;
+      if (consumedAsGroupMember.has(ta.object.id)) continue;
+      const members = membersByLeader[ta.object.id];
+      pageAnnotations.push({
+        page,
+        annotation: ta,
+        replies: repliesByParent[ta.object.id] ?? [],
+        ...members && members.length > 0 ? { groupMembers: members } : {}
+      });
     }
     if (pageAnnotations.length > 0) {
       out[page] = pageAnnotations;
@@ -323,6 +340,62 @@ const getSelectionGroupingAction = (s) => {
   }
   return selected.length >= 2 ? "group" : "disabled";
 };
+const inkTools = [
+  {
+    id: "ink",
+    name: "Pen",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent !== "InkHighlight" ? 5 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.INK,
+      strokeColor: "#E44234",
+      color: "#E44234",
+      // deprecated alias
+      opacity: 1,
+      strokeWidth: 6
+    },
+    behavior: {
+      commitDelay: 800
+    }
+  },
+  {
+    id: "inkHighlighter",
+    name: "Ink Highlighter",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent === "InkHighlight" ? 10 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: true,
+      lockAspectRatio: false,
+      lockGroupAspectRatio: (a) => {
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
+      }
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.INK,
+      intent: "InkHighlight",
+      strokeColor: "#FFCD45",
+      color: "#FFCD45",
+      // deprecated alias
+      opacity: 1,
+      strokeWidth: 14,
+      blendMode: PdfBlendMode.Multiply
+    },
+    behavior: {
+      commitDelay: 800,
+      smartLineRecognition: true,
+      smartLineThreshold: 0.15
+    }
+  }
+];
 const defaultTools = [
   // Text Markup Tools
   {
@@ -334,6 +407,7 @@ const defaultTools = [
       textSelection: true,
       isDraggable: false,
       isResizable: false,
+      isRotatable: false,
       // Text markup annotations are anchored to text and should not move/resize in groups
       isGroupDraggable: false,
       isGroupResizable: false
@@ -356,6 +430,7 @@ const defaultTools = [
       textSelection: true,
       isDraggable: false,
       isResizable: false,
+      isRotatable: false,
       isGroupDraggable: false,
       isGroupResizable: false
     },
@@ -376,6 +451,7 @@ const defaultTools = [
       textSelection: true,
       isDraggable: false,
       isResizable: false,
+      isRotatable: false,
       isGroupDraggable: false,
       isGroupResizable: false
     },
@@ -396,6 +472,7 @@ const defaultTools = [
       textSelection: true,
       isDraggable: false,
       isResizable: false,
+      isRotatable: false,
       isGroupDraggable: false,
       isGroupResizable: false
     },
@@ -407,53 +484,61 @@ const defaultTools = [
       opacity: 1
     }
   },
-  // Drawing Tools
+  // Insert Text (Caret with intent Insert)
   {
-    id: "ink",
-    name: "Pen",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent !== "InkHighlight" ? 5 : 0,
+    id: "insertText",
+    name: "Insert Text",
+    matchScore: (a) => {
+      var _a;
+      if (a.type !== PdfAnnotationSubtype.CARET) return 0;
+      return ((_a = a.intent) == null ? void 0 : _a.includes("Insert")) ? 2 : 1;
+    },
     interaction: {
       exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: false
+      textSelection: true,
+      showSelectionRects: true,
+      isDraggable: false,
+      isResizable: false,
+      isRotatable: false,
+      isGroupDraggable: false,
+      isGroupResizable: false
     },
     defaults: {
-      type: PdfAnnotationSubtype.INK,
+      type: PdfAnnotationSubtype.CARET,
       strokeColor: "#E44234",
-      color: "#E44234",
-      // deprecated alias
       opacity: 1,
-      strokeWidth: 6
+      intent: "Insert"
     }
   },
+  // Replace Text (StrikeOut + Caret group)
   {
-    id: "inkHighlighter",
-    name: "Ink Highlighter",
-    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent === "InkHighlight" ? 10 : 0,
+    id: "replaceText",
+    name: "Replace Text",
+    matchScore: (a) => {
+      var _a, _b;
+      if (a.type === PdfAnnotationSubtype.STRIKEOUT && ((_a = a.intent) == null ? void 0 : _a.includes("StrikeOutTextEdit")))
+        return 2;
+      if (a.type === PdfAnnotationSubtype.CARET && ((_b = a.intent) == null ? void 0 : _b.includes("Replace"))) return 2;
+      return 0;
+    },
     interaction: {
       exclusive: false,
-      cursor: "crosshair",
-      isDraggable: true,
-      isResizable: true,
-      lockAspectRatio: false,
-      lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
-      }
+      textSelection: true,
+      isDraggable: false,
+      isResizable: false,
+      isRotatable: false,
+      isGroupDraggable: false,
+      isGroupResizable: false
     },
     defaults: {
-      type: PdfAnnotationSubtype.INK,
-      intent: "InkHighlight",
-      strokeColor: "#FFCD45",
-      color: "#FFCD45",
-      // deprecated alias
+      type: PdfAnnotationSubtype.STRIKEOUT,
+      strokeColor: "#E44234",
       opacity: 1,
-      strokeWidth: 14,
-      blendMode: PdfBlendMode.Multiply
+      intent: "StrikeOutTextEdit"
     }
   },
+  // Drawing Tools
+  ...inkTools,
   // Shape Tools
   {
     id: "circle",
@@ -466,8 +551,8 @@ const defaultTools = [
       isResizable: true,
       lockAspectRatio: false,
       lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
       }
     },
     defaults: {
@@ -494,8 +579,8 @@ const defaultTools = [
       isResizable: true,
       lockAspectRatio: false,
       lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
       }
     },
     defaults: {
@@ -525,8 +610,8 @@ const defaultTools = [
       isGroupResizable: true,
       // Scales proportionally in a group
       lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
       }
     },
     defaults: {
@@ -556,8 +641,8 @@ const defaultTools = [
       isGroupResizable: true,
       // Scales proportionally in a group
       lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
       }
     },
     defaults: {
@@ -592,8 +677,8 @@ const defaultTools = [
       isGroupResizable: true,
       // Scales proportionally in a group
       lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
       }
     },
     defaults: {
@@ -618,8 +703,8 @@ const defaultTools = [
       isGroupResizable: true,
       // Scales proportionally in a group
       lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
       }
     },
     defaults: {
@@ -631,6 +716,26 @@ const defaultTools = [
     }
   },
   // Text & Stamp
+  {
+    id: "textComment",
+    name: "Comment",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.TEXT && !a.inReplyToId ? 1 : 0,
+    interaction: {
+      exclusive: false,
+      cursor: "crosshair",
+      isDraggable: true,
+      isResizable: false,
+      isRotatable: false
+    },
+    defaults: {
+      type: PdfAnnotationSubtype.TEXT,
+      strokeColor: "#FFCD45",
+      opacity: 1
+    },
+    behavior: {
+      selectAfterCreate: true
+    }
+  },
   {
     id: "freeText",
     name: "Free Text",
@@ -642,8 +747,8 @@ const defaultTools = [
       isResizable: true,
       lockAspectRatio: false,
       lockGroupAspectRatio: (a) => {
-        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
+        const r2 = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r2 >= 6 && r2 <= 84;
       }
     },
     defaults: {
@@ -952,7 +1057,7 @@ const reducer = (state, action) => {
             },
             byUid: {
               ...docState.byUid,
-              [uid]: { commitState: "new", object: annotation }
+              [uid]: { commitState: "new", object: annotation, dictMode: true }
             },
             hasPendingChanges: true
           }
@@ -1086,6 +1191,18 @@ function useState(initialValue) {
   };
   return [getValue, setValue];
 }
+function isLineLike(points, threshold) {
+  if (points.length < 3) return true;
+  const A = points[0];
+  const B = points[points.length - 1];
+  const len = Math.hypot(B.x - A.x, B.y - A.y);
+  if (len < 5) return false;
+  const maxDev = points.reduce((max, P) => {
+    const d = Math.abs((B.x - A.x) * (A.y - P.y) - (A.x - P.x) * (B.y - A.y)) / len;
+    return Math.max(max, d);
+  }, 0);
+  return maxDev / len < threshold;
+}
 const inkHandlerFactory = {
   annotationType: PdfAnnotationSubtype.INK,
   create(context) {
@@ -1121,7 +1238,8 @@ const inkHandlerFactory = {
         data: {
           ...defaults,
           rect: bounds,
-          inkList: strokes
+          inkList: strokes,
+          blendMode: defaults.blendMode
         }
       };
     };
@@ -1149,6 +1267,37 @@ const inkHandlerFactory = {
         var _a;
         setIsDrawing(false);
         (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+        const tool = getTool();
+        const behavior = tool == null ? void 0 : tool.behavior;
+        if (behavior == null ? void 0 : behavior.smartLineRecognition) {
+          const threshold = behavior.smartLineThreshold ?? 0.15;
+          const strokes = getStrokes();
+          const last = strokes[strokes.length - 1];
+          if (last && last.points.length > 1 && isLineLike(last.points, threshold)) {
+            const first = last.points[0];
+            const end = last.points[last.points.length - 1];
+            const dx = end.x - first.x;
+            const dy = end.y - first.y;
+            const angleDeg = Math.atan2(Math.abs(dy), Math.abs(dx)) * (180 / Math.PI);
+            const snapAngleDeg = behavior.snapAngleDeg ?? 15;
+            if (angleDeg <= snapAngleDeg) {
+              const avgY = last.points.reduce((sum, p) => sum + p.y, 0) / last.points.length;
+              last.points = [
+                { x: first.x, y: avgY },
+                { x: end.x, y: avgY }
+              ];
+            } else if (angleDeg >= 90 - snapAngleDeg) {
+              const avgX = last.points.reduce((sum, p) => sum + p.x, 0) / last.points.length;
+              last.points = [
+                { x: avgX, y: first.y },
+                { x: avgX, y: end.y }
+              ];
+            }
+            setStrokes([...strokes]);
+            onPreview(getPreview());
+          }
+        }
+        const commitDelay = (behavior == null ? void 0 : behavior.commitDelay) ?? 800;
         if (timerRef.current) clearTimeout(timerRef.current);
         timerRef.current = setTimeout(() => {
           const strokes = getStrokes();
@@ -1169,7 +1318,7 @@ const inkHandlerFactory = {
           }
           setStrokes([]);
           onPreview(null);
-        }, 800);
+        }, commitDelay);
       },
       onPointerCancel: (_, evt) => {
         var _a;
@@ -1182,45 +1331,6 @@ const inkHandlerFactory = {
     };
   }
 };
-function useClickDetector({
-  threshold = 5,
-  getTool,
-  onClickDetected
-}) {
-  const [getStartPos, setStartPos] = useState(null);
-  const [getHasMoved, setHasMoved] = useState(false);
-  return {
-    onStart: (pos) => {
-      setStartPos(pos);
-      setHasMoved(false);
-    },
-    onMove: (pos) => {
-      const start = getStartPos();
-      if (!start || getHasMoved()) return;
-      const distance = Math.sqrt(Math.pow(pos.x - start.x, 2) + Math.pow(pos.y - start.y, 2));
-      if (distance > threshold) {
-        setHasMoved(true);
-      }
-    },
-    onEnd: (pos) => {
-      var _a;
-      const start = getStartPos();
-      if (start && !getHasMoved()) {
-        const tool = getTool();
-        if (tool && "clickBehavior" in tool && ((_a = tool.clickBehavior) == null ? void 0 : _a.enabled)) {
-          onClickDetected(pos, tool);
-        }
-      }
-      setStartPos(null);
-      setHasMoved(false);
-    },
-    hasMoved: getHasMoved,
-    reset: () => {
-      setStartPos(null);
-      setHasMoved(false);
-    }
-  };
-}
 function createArrowHandler(isClosed) {
   const calculateGeometry = (sw) => {
     const len = sw * 9;
@@ -1280,14 +1390,14 @@ const LINE_ENDING_HANDLERS = {
   },
   [PdfAnnotationLineEnding.Circle]: {
     getSvgPath: (sw) => {
-      const r = sw * 5 / 2;
-      return `M ${r} 0 A ${r} ${r} 0 1 1 ${-r} 0 A ${r} ${r} 0 1 1 ${r} 0`;
+      const r2 = sw * 5 / 2;
+      return `M ${r2} 0 A ${r2} ${r2} 0 1 1 ${-r2} 0 A ${r2} ${r2} 0 1 1 ${r2} 0`;
     },
     getLocalPoints: (sw) => {
-      const r = sw * 5 / 2;
+      const r2 = sw * 5 / 2;
       return [
-        { x: -r, y: -r },
-        { x: r, y: r }
+        { x: -r2, y: -r2 },
+        { x: r2, y: r2 }
       ];
     },
     getRotation: () => 0,
@@ -1429,7 +1539,7 @@ function createEnding(ending, strokeWidth, rad, px, py) {
   if (!ending) return null;
   const handler = LINE_ENDING_HANDLERS[ending];
   if (!handler) return null;
-  const toDeg = (r) => r * 180 / Math.PI;
+  const toDeg = (r2) => r2 * 180 / Math.PI;
   const rotationAngle = handler.getRotation(rad);
   return {
     d: handler.getSvgPath(strokeWidth),
@@ -1601,6 +1711,75 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   rotatePointAroundCenter: rotatePointAround,
   rotateVertices
 }, Symbol.toStringTag, { value: "Module" }));
+const COMMENT_SIZE = 24;
+const textHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.TEXT,
+  create(context) {
+    const { onCommit, getTool, pageSize } = context;
+    return {
+      onPointerDown: (pos) => {
+        const tool = getTool();
+        if (!tool) return;
+        const rect = {
+          origin: { x: pos.x - COMMENT_SIZE / 2, y: pos.y - COMMENT_SIZE / 2 },
+          size: { width: COMMENT_SIZE, height: COMMENT_SIZE }
+        };
+        let anno = {
+          ...tool.defaults,
+          rect,
+          type: PdfAnnotationSubtype.TEXT,
+          icon: tool.defaults.icon ?? PdfAnnotationIcon.Comment,
+          contents: tool.defaults.contents ?? "",
+          flags: tool.defaults.flags ?? ["print", "noRotate", "noZoom"],
+          pageIndex: context.pageIndex,
+          id: uuidV4(),
+          created: /* @__PURE__ */ new Date()
+        };
+        anno = clampAnnotationToPage(anno, pageSize);
+        onCommit(anno);
+      }
+    };
+  }
+};
+function useClickDetector({
+  threshold = 5,
+  getTool,
+  onClickDetected
+}) {
+  const [getStartPos, setStartPos] = useState(null);
+  const [getHasMoved, setHasMoved] = useState(false);
+  return {
+    onStart: (pos) => {
+      setStartPos(pos);
+      setHasMoved(false);
+    },
+    onMove: (pos) => {
+      const start = getStartPos();
+      if (!start || getHasMoved()) return;
+      const distance2 = Math.sqrt(Math.pow(pos.x - start.x, 2) + Math.pow(pos.y - start.y, 2));
+      if (distance2 > threshold) {
+        setHasMoved(true);
+      }
+    },
+    onEnd: (pos) => {
+      var _a;
+      const start = getStartPos();
+      if (start && !getHasMoved()) {
+        const tool = getTool();
+        if (tool && "clickBehavior" in tool && ((_a = tool.clickBehavior) == null ? void 0 : _a.enabled)) {
+          onClickDetected(pos, tool);
+        }
+      }
+      setStartPos(null);
+      setHasMoved(false);
+    },
+    hasMoved: getHasMoved,
+    reset: () => {
+      setStartPos(null);
+      setHasMoved(false);
+    }
+  };
+}
 const freeTextHandlerFactory = {
   annotationType: PdfAnnotationSubtype.FREETEXT,
   create(context) {
@@ -2003,6 +2182,554 @@ const polylineHandlerFactory = {
     };
   }
 };
+function convertAABBRectToUnrotatedSpace(newAABBRect, originalAABBRect, originalUnrotatedRect, rotationDegrees) {
+  const theta = rotationDegrees * Math.PI / 180;
+  const A = Math.abs(Math.cos(theta));
+  const B = Math.abs(Math.sin(theta));
+  const det = A * A - B * B;
+  const newAABBw = newAABBRect.size.width;
+  const newAABBh = newAABBRect.size.height;
+  let newWidth;
+  let newHeight;
+  if (Math.abs(det) > 1e-6) {
+    newWidth = (A * newAABBw - B * newAABBh) / det;
+    newHeight = (A * newAABBh - B * newAABBw) / det;
+    newWidth = Math.max(newWidth, 1);
+    newHeight = Math.max(newHeight, 1);
+  } else {
+    const origArea = originalAABBRect.size.width * originalAABBRect.size.height;
+    const newArea = newAABBw * newAABBh;
+    const uniformScale = origArea > 0 ? Math.sqrt(newArea / origArea) : 1;
+    newWidth = originalUnrotatedRect.size.width * uniformScale;
+    newHeight = originalUnrotatedRect.size.height * uniformScale;
+  }
+  const newCenterX = newAABBRect.origin.x + newAABBw / 2;
+  const newCenterY = newAABBRect.origin.y + newAABBh / 2;
+  return {
+    origin: { x: newCenterX - newWidth / 2, y: newCenterY - newHeight / 2 },
+    size: { width: newWidth, height: newHeight }
+  };
+}
+const ANGLE_180 = Math.PI;
+const ANGLE_90 = Math.PI / 2;
+const ANGLE_34 = 34 * Math.PI / 180;
+const ANGLE_30 = 30 * Math.PI / 180;
+const ANGLE_12 = 12 * Math.PI / 180;
+class PathBuilder {
+  constructor() {
+    this.parts = [];
+    this.bbox = {
+      minX: Infinity,
+      minY: Infinity,
+      maxX: -Infinity,
+      maxY: -Infinity
+    };
+    this.started = false;
+  }
+  moveTo(x, y) {
+    const sy = -y;
+    this.updateBBox(x, sy);
+    this.parts.push(`M ${r(x)} ${r(sy)}`);
+    this.started = true;
+  }
+  curveTo(x1, y1, x2, y2, x3, y3) {
+    const sy1 = -y1;
+    const sy2 = -y2;
+    const sy3 = -y3;
+    this.updateBBox(x1, sy1);
+    this.updateBBox(x2, sy2);
+    this.updateBBox(x3, sy3);
+    this.parts.push(`C ${r(x1)} ${r(sy1)}, ${r(x2)} ${r(sy2)}, ${r(x3)} ${r(sy3)}`);
+  }
+  close() {
+    if (this.started) {
+      this.parts.push("Z");
+    }
+  }
+  build(lineWidth) {
+    const d = lineWidth > 0 ? lineWidth / 2 : 0;
+    return {
+      path: this.parts.join(" "),
+      bbox: {
+        minX: this.bbox.minX - d,
+        minY: this.bbox.minY - d,
+        maxX: this.bbox.maxX + d,
+        maxY: this.bbox.maxY + d
+      }
+    };
+  }
+  updateBBox(x, y) {
+    if (x < this.bbox.minX) this.bbox.minX = x;
+    if (y < this.bbox.minY) this.bbox.minY = y;
+    if (x > this.bbox.maxX) this.bbox.maxX = x;
+    if (y > this.bbox.maxY) this.bbox.maxY = y;
+  }
+}
+function r(n) {
+  return Number(n.toFixed(4)).toString();
+}
+function distance(a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function cosine(dx, hypot) {
+  return hypot === 0 ? 0 : dx / hypot;
+}
+function sine(dy, hypot) {
+  return hypot === 0 ? 0 : dy / hypot;
+}
+function polygonDirection(pts) {
+  let a = 0;
+  const len = pts.length;
+  for (let i = 0; i < len; i++) {
+    const j = (i + 1) % len;
+    a += pts[i].x * pts[j].y - pts[i].y * pts[j].x;
+  }
+  return a;
+}
+function ensurePositiveWinding(pts) {
+  if (polygonDirection(pts) < 0) {
+    pts.reverse();
+  }
+}
+function removeZeroLengthSegments(polygon) {
+  if (polygon.length <= 2) return polygon;
+  const tolerance = 0.5;
+  const result = [polygon[0]];
+  for (let i = 1; i < polygon.length; i++) {
+    const prev = result[result.length - 1];
+    const cur = polygon[i];
+    if (Math.abs(cur.x - prev.x) >= tolerance || Math.abs(cur.y - prev.y) >= tolerance) {
+      result.push(cur);
+    }
+  }
+  return result;
+}
+function arcSegment(startAng, endAng, cx, cy, rx, ry, out, addMoveTo) {
+  const cosA = Math.cos(startAng);
+  const sinA = Math.sin(startAng);
+  const cosB = Math.cos(endAng);
+  const sinB = Math.sin(endAng);
+  const denom = Math.sin((endAng - startAng) / 2);
+  if (denom === 0) {
+    if (addMoveTo) {
+      out.moveTo(cx + rx * cosA, cy + ry * sinA);
+    }
+    return;
+  }
+  const bcp = 4 / 3 * (1 - Math.cos((endAng - startAng) / 2)) / denom;
+  const p1x = cx + rx * (cosA - bcp * sinA);
+  const p1y = cy + ry * (sinA + bcp * cosA);
+  const p2x = cx + rx * (cosB + bcp * sinB);
+  const p2y = cy + ry * (sinB - bcp * cosB);
+  const p3x = cx + rx * cosB;
+  const p3y = cy + ry * sinB;
+  if (addMoveTo) {
+    out.moveTo(cx + rx * cosA, cy + ry * sinA);
+  }
+  out.curveTo(p1x, p1y, p2x, p2y, p3x, p3y);
+}
+function arcSegmentToArray(startAng, endAng, cx, cy, rx, ry) {
+  const cosA = Math.cos(startAng);
+  const sinA = Math.sin(startAng);
+  const cosB = Math.cos(endAng);
+  const sinB = Math.sin(endAng);
+  const denom = Math.sin((endAng - startAng) / 2);
+  if (denom === 0) return [];
+  const bcp = 4 / 3 * (1 - Math.cos((endAng - startAng) / 2)) / denom;
+  return [
+    { x: cx + rx * (cosA - bcp * sinA), y: cy + ry * (sinA + bcp * cosA) },
+    { x: cx + rx * (cosB + bcp * sinB), y: cy + ry * (sinB - bcp * cosB) },
+    { x: cx + rx * cosB, y: cy + ry * sinB }
+  ];
+}
+function getArc(startAng, endAng, rx, ry, cx, cy, out, addMoveTo) {
+  const angleIncr = ANGLE_90;
+  let angleTodo = endAng - startAng;
+  while (angleTodo < 0) angleTodo += 2 * Math.PI;
+  const sweep = angleTodo;
+  let angleDone = 0;
+  if (addMoveTo) {
+    out.moveTo(cx + rx * Math.cos(startAng), cy + ry * Math.sin(startAng));
+  }
+  while (angleTodo > angleIncr) {
+    arcSegment(startAng + angleDone, startAng + angleDone + angleIncr, cx, cy, rx, ry, out, false);
+    angleDone += angleIncr;
+    angleTodo -= angleIncr;
+  }
+  if (angleTodo > 0) {
+    arcSegment(startAng + angleDone, startAng + sweep, cx, cy, rx, ry, out, false);
+  }
+}
+function addCornerCurl(anglePrev, angleCur, radius, cx, cy, alpha, alphaPrev, out, addMoveTo) {
+  let a = anglePrev + ANGLE_180 + alphaPrev;
+  const b = anglePrev + ANGLE_180 + alphaPrev - 22 * Math.PI / 180;
+  arcSegment(a, b, cx, cy, radius, radius, out, addMoveTo);
+  a = b;
+  const bEnd = angleCur - alpha;
+  getArc(a, bEnd, radius, radius, cx, cy, out, false);
+}
+function addFirstIntermediateCurl(angleCur, r2, alpha, cx, cy, out) {
+  const a = angleCur + ANGLE_180;
+  arcSegment(a + alpha, a + alpha - ANGLE_30, cx, cy, r2, r2, out, false);
+  arcSegment(a + alpha - ANGLE_30, a + ANGLE_90, cx, cy, r2, r2, out, false);
+  arcSegment(a + ANGLE_90, a + ANGLE_180 - ANGLE_34, cx, cy, r2, r2, out, false);
+}
+function getIntermediateCurlTemplate(angleCur, r2) {
+  const pts = [];
+  const a = angleCur + ANGLE_180;
+  pts.push(...arcSegmentToArray(a + ANGLE_34, a + ANGLE_12, 0, 0, r2, r2));
+  pts.push(...arcSegmentToArray(a + ANGLE_12, a + ANGLE_90, 0, 0, r2, r2));
+  pts.push(...arcSegmentToArray(a + ANGLE_90, a + ANGLE_180 - ANGLE_34, 0, 0, r2, r2));
+  return pts;
+}
+function outputCurlTemplate(template, x, y, out) {
+  for (let i = 0; i + 2 < template.length; i += 3) {
+    const a = template[i];
+    const b = template[i + 1];
+    const c = template[i + 2];
+    out.curveTo(a.x + x, a.y + y, b.x + x, b.y + y, c.x + x, c.y + y);
+  }
+}
+function computeParamsPolygon(idealRadius, k, length) {
+  if (length === 0) return { n: -1, adjustedRadius: idealRadius };
+  const cornerSpace = 2 * k * idealRadius;
+  const remaining = length - cornerSpace;
+  if (remaining <= 0) {
+    return { n: 0, adjustedRadius: idealRadius };
+  }
+  const idealAdvance = 2 * k * idealRadius;
+  const n = Math.max(1, Math.ceil(remaining / idealAdvance));
+  const adjustedRadius = remaining / (n * 2 * k);
+  return { n, adjustedRadius };
+}
+function cloudyPolygonImpl(vertices, isEllipse, intensity, lineWidth, out) {
+  let polygon = removeZeroLengthSegments(vertices);
+  ensurePositiveWinding(polygon);
+  const numPoints = polygon.length;
+  if (numPoints < 2) return;
+  if (intensity <= 0) {
+    out.moveTo(polygon[0].x, polygon[0].y);
+    for (let i = 1; i < numPoints; i++) {
+      out.curveTo(
+        polygon[i].x,
+        polygon[i].y,
+        polygon[i].x,
+        polygon[i].y,
+        polygon[i].x,
+        polygon[i].y
+      );
+    }
+    return;
+  }
+  let idealRadius = isEllipse ? getEllipseCloudRadius(intensity, lineWidth) : getPolygonCloudRadius(intensity, lineWidth);
+  if (idealRadius < 0.5) idealRadius = 0.5;
+  const k = Math.cos(ANGLE_34);
+  const edgeAlphas = [];
+  for (let j = 0; j + 1 < numPoints; j++) {
+    const len = distance(polygon[j], polygon[j + 1]);
+    if (len <= 0 || len >= 2 * k * idealRadius) {
+      edgeAlphas.push(ANGLE_34);
+    } else {
+      edgeAlphas.push(Math.acos(Math.min(1, len / (2 * idealRadius))));
+    }
+  }
+  let anglePrev = 0;
+  let outputStarted = false;
+  for (let j = 0; j + 1 < numPoints; j++) {
+    const pt = polygon[j];
+    const ptNext = polygon[j + 1];
+    const len = distance(pt, ptNext);
+    if (len === 0) continue;
+    const params = computeParamsPolygon(idealRadius, k, len);
+    if (params.n < 0) {
+      if (!outputStarted) {
+        out.moveTo(pt.x, pt.y);
+        outputStarted = true;
+      }
+      continue;
+    }
+    const edgeRadius = Math.max(0.5, params.adjustedRadius);
+    const intermAdvance = 2 * k * edgeRadius;
+    const firstAdvance = k * idealRadius + k * edgeRadius;
+    let angleCur = Math.atan2(ptNext.y - pt.y, ptNext.x - pt.x);
+    if (j === 0) {
+      const ptPrev = polygon[numPoints - 2];
+      anglePrev = Math.atan2(pt.y - ptPrev.y, pt.x - ptPrev.x);
+    }
+    const cos = cosine(ptNext.x - pt.x, len);
+    const sin = sine(ptNext.y - pt.y, len);
+    let x = pt.x;
+    let y = pt.y;
+    const alpha = edgeAlphas[j];
+    const prevEdgeIdx = j === 0 ? numPoints - 2 : j - 1;
+    const alphaPrevEdge = edgeAlphas[prevEdgeIdx] ?? ANGLE_34;
+    addCornerCurl(
+      anglePrev,
+      angleCur,
+      idealRadius,
+      pt.x,
+      pt.y,
+      alpha,
+      alphaPrevEdge,
+      out,
+      !outputStarted
+    );
+    outputStarted = true;
+    if (params.n === 0) {
+      x += len * cos;
+      y += len * sin;
+    } else {
+      x += firstAdvance * cos;
+      y += firstAdvance * sin;
+      let numInterm = params.n;
+      if (params.n >= 1) {
+        addFirstIntermediateCurl(angleCur, edgeRadius, ANGLE_34, x, y, out);
+        x += intermAdvance * cos;
+        y += intermAdvance * sin;
+        numInterm = params.n - 1;
+      }
+      const template = getIntermediateCurlTemplate(angleCur, edgeRadius);
+      for (let i = 0; i < numInterm; i++) {
+        outputCurlTemplate(template, x, y, out);
+        x += intermAdvance * cos;
+        y += intermAdvance * sin;
+      }
+    }
+    anglePrev = angleCur;
+  }
+}
+function flattenEllipse(left, bottom, right, top) {
+  const cx = (left + right) / 2;
+  const cy = (bottom + top) / 2;
+  const rx = (right - left) / 2;
+  const ry = (top - bottom) / 2;
+  if (rx <= 0 || ry <= 0) return [];
+  const numSegments = Math.max(32, Math.ceil(Math.max(rx, ry) * 2));
+  const points = [];
+  for (let i = 0; i <= numSegments; i++) {
+    const angle = 2 * Math.PI * i / numSegments;
+    points.push({
+      x: cx + rx * Math.cos(angle),
+      y: cy + ry * Math.sin(angle)
+    });
+  }
+  return points;
+}
+function getEllipseCloudRadius(intensity, lineWidth) {
+  return 4.75 * intensity + 0.5 * lineWidth;
+}
+function getPolygonCloudRadius(intensity, lineWidth) {
+  return 4 * intensity + 0.5 * lineWidth;
+}
+function cloudyEllipseImpl(left, bottom, right, top, intensity, lineWidth, out) {
+  if (intensity <= 0) {
+    const rx = Math.abs(right - left) / 2;
+    const ry = Math.abs(top - bottom) / 2;
+    const cx = (left + right) / 2;
+    const cy = (bottom + top) / 2;
+    getArc(0, 2 * Math.PI, rx, ry, cx, cy, out, true);
+    return;
+  }
+  const width = right - left;
+  const height = top - bottom;
+  let cloudRadius = getEllipseCloudRadius(intensity, lineWidth);
+  const threshold1 = 0.5 * cloudRadius;
+  if (width < threshold1 && height < threshold1) {
+    const rx = Math.abs(right - left) / 2;
+    const ry = Math.abs(top - bottom) / 2;
+    const cx = (left + right) / 2;
+    const cy = (bottom + top) / 2;
+    getArc(0, 2 * Math.PI, rx, ry, cx, cy, out, true);
+    return;
+  }
+  const threshold2 = 5;
+  if (width < threshold2 && height > 20 || width > 20 && height < threshold2) {
+    cloudyPolygonImpl(
+      [
+        { x: left, y: bottom },
+        { x: right, y: bottom },
+        { x: right, y: top },
+        { x: left, y: top },
+        { x: left, y: bottom }
+      ],
+      true,
+      intensity,
+      lineWidth,
+      out
+    );
+    return;
+  }
+  const radiusAdj = Math.sin(ANGLE_12) * cloudRadius - 1.5;
+  let adjLeft = left;
+  let adjRight = right;
+  let adjBottom = bottom;
+  let adjTop = top;
+  if (width > 2 * radiusAdj) {
+    adjLeft += radiusAdj;
+    adjRight -= radiusAdj;
+  } else {
+    const mid = (left + right) / 2;
+    adjLeft = mid - 0.1;
+    adjRight = mid + 0.1;
+  }
+  if (height > 2 * radiusAdj) {
+    adjBottom += radiusAdj;
+    adjTop -= radiusAdj;
+  } else {
+    const mid = (top + bottom) / 2;
+    adjTop = mid + 0.1;
+    adjBottom = mid - 0.1;
+  }
+  const flatPolygon = flattenEllipse(adjLeft, adjBottom, adjRight, adjTop);
+  const numFlatPts = flatPolygon.length;
+  if (numFlatPts < 2) return;
+  let totLen = 0;
+  for (let i = 1; i < numFlatPts; i++) {
+    totLen += distance(flatPolygon[i - 1], flatPolygon[i]);
+  }
+  const k = Math.cos(ANGLE_34);
+  let curlAdvance = 2 * k * cloudRadius;
+  let n = Math.ceil(totLen / curlAdvance);
+  if (n < 2) {
+    const rx = Math.abs(right - left) / 2;
+    const ry = Math.abs(top - bottom) / 2;
+    const cx = (left + right) / 2;
+    const cy = (bottom + top) / 2;
+    getArc(0, 2 * Math.PI, rx, ry, cx, cy, out, true);
+    return;
+  }
+  curlAdvance = totLen / n;
+  cloudRadius = curlAdvance / (2 * k);
+  if (cloudRadius < 0.5) {
+    cloudRadius = 0.5;
+    curlAdvance = 2 * k * cloudRadius;
+  } else if (cloudRadius < 3) {
+    const rx = Math.abs(right - left) / 2;
+    const ry = Math.abs(top - bottom) / 2;
+    const cx = (left + right) / 2;
+    const cy = (bottom + top) / 2;
+    getArc(0, 2 * Math.PI, rx, ry, cx, cy, out, true);
+    return;
+  }
+  const centerPoints = [];
+  let lengthRemain = 0;
+  const comparisonToler = lineWidth * 0.1;
+  for (let i = 0; i + 1 < numFlatPts; i++) {
+    const p1 = flatPolygon[i];
+    const p2 = flatPolygon[i + 1];
+    const segDx = p2.x - p1.x;
+    const segDy = p2.y - p1.y;
+    const segLen = distance(p1, p2);
+    if (segLen === 0) continue;
+    let lengthTodo = segLen + lengthRemain;
+    if (lengthTodo >= curlAdvance - comparisonToler || i === numFlatPts - 2) {
+      const cos = cosine(segDx, segLen);
+      const sin = sine(segDy, segLen);
+      let d = curlAdvance - lengthRemain;
+      while (lengthTodo >= curlAdvance - comparisonToler) {
+        centerPoints.push({ x: p1.x + d * cos, y: p1.y + d * sin });
+        lengthTodo -= curlAdvance;
+        d += curlAdvance;
+      }
+      lengthRemain = Math.max(0, lengthTodo);
+    } else {
+      lengthRemain += segLen;
+    }
+  }
+  const cpLen = centerPoints.length;
+  let epAnglePrev = 0;
+  let epAlphaPrev = 0;
+  for (let i = 0; i < cpLen; i++) {
+    const idxNext = (i + 1) % cpLen;
+    const pt = centerPoints[i];
+    const ptNext = centerPoints[idxNext];
+    if (i === 0) {
+      const ptPrev = centerPoints[cpLen - 1];
+      epAnglePrev = Math.atan2(pt.y - ptPrev.y, pt.x - ptPrev.x);
+      epAlphaPrev = computeParamsEllipse(ptPrev, pt, cloudRadius, curlAdvance);
+    }
+    const angleCur = Math.atan2(ptNext.y - pt.y, ptNext.x - pt.x);
+    const alpha = computeParamsEllipse(pt, ptNext, cloudRadius, curlAdvance);
+    addCornerCurl(epAnglePrev, angleCur, cloudRadius, pt.x, pt.y, alpha, epAlphaPrev, out, i === 0);
+    epAnglePrev = angleCur;
+    epAlphaPrev = alpha;
+  }
+}
+function computeParamsEllipse(pt, ptNext, r2, curlAdv) {
+  const len = distance(pt, ptNext);
+  if (len === 0) return ANGLE_34;
+  const e = len - curlAdv;
+  const arg = (curlAdv / 2 + e / 2) / r2;
+  return arg < -1 || arg > 1 ? 0 : Math.acos(arg);
+}
+function getCloudyBorderExtent(intensity, lineWidth, isEllipse) {
+  const cloudRadius = isEllipse ? getEllipseCloudRadius(intensity, lineWidth) : getPolygonCloudRadius(intensity, lineWidth);
+  return cloudRadius + lineWidth / 2;
+}
+function generateCloudyRectanglePath(rect, rd, intensity, lineWidth) {
+  const out = new PathBuilder();
+  let left = 0;
+  let top = 0;
+  let right = rect.width;
+  let bottom = rect.height;
+  if (rd) {
+    left += rd.left;
+    top += rd.top;
+    right -= rd.right;
+    bottom -= rd.bottom;
+  } else {
+    left += lineWidth / 2;
+    top += lineWidth / 2;
+    right -= lineWidth / 2;
+    bottom -= lineWidth / 2;
+  }
+  const polygon = [
+    { x: left, y: -top },
+    { x: right, y: -top },
+    { x: right, y: -bottom },
+    { x: left, y: -bottom },
+    { x: left, y: -top }
+  ];
+  cloudyPolygonImpl(polygon, false, intensity, lineWidth, out);
+  out.close();
+  return out.build(lineWidth);
+}
+function generateCloudyEllipsePath(rect, rd, intensity, lineWidth) {
+  const out = new PathBuilder();
+  let left = 0;
+  let top = 0;
+  let right = rect.width;
+  let bottom = rect.height;
+  if (rd) {
+    left += rd.left;
+    top += rd.top;
+    right -= rd.right;
+    bottom -= rd.bottom;
+  }
+  cloudyEllipseImpl(left, -bottom, right, -top, intensity, lineWidth, out);
+  out.close();
+  return out.build(lineWidth);
+}
+function generateCloudyPolygonPath(vertices, rectOrigin, intensity, lineWidth) {
+  const out = new PathBuilder();
+  if (vertices.length < 3) {
+    return out.build(lineWidth);
+  }
+  const localPts = vertices.map((v) => ({
+    x: v.x - rectOrigin.x,
+    y: -(v.y - rectOrigin.y)
+  }));
+  const first = localPts[0];
+  const last = localPts[localPts.length - 1];
+  if (first.x !== last.x || first.y !== last.y) {
+    localPts.push({ x: first.x, y: first.y });
+  }
+  cloudyPolygonImpl(localPts, false, intensity, lineWidth, out);
+  out.close();
+  return out.build(lineWidth);
+}
 const HANDLE_SIZE_PX = 14;
 const polygonHandlerFactory = {
   annotationType: PdfAnnotationSubtype.POLYGON,
@@ -2041,7 +2768,9 @@ const polygonHandlerFactory = {
       if (vertices.length < 3) return;
       const defaults = getDefaults();
       if (!defaults) return;
-      const rect = expandRect(rectFromPoints(vertices), defaults.strokeWidth / 2);
+      const intensity = defaults.cloudyBorderIntensity ?? 0;
+      const pad = intensity > 0 ? getCloudyBorderExtent(intensity, defaults.strokeWidth, false) : defaults.strokeWidth / 2;
+      const rect = expandRect(rectFromPoints(vertices), pad);
       const anno = {
         ...defaults,
         vertices,
@@ -2049,7 +2778,10 @@ const polygonHandlerFactory = {
         type: PdfAnnotationSubtype.POLYGON,
         pageIndex: context.pageIndex,
         id: uuidV4(),
-        created: /* @__PURE__ */ new Date()
+        created: /* @__PURE__ */ new Date(),
+        ...intensity > 0 && {
+          rectangleDifferences: { left: pad, top: pad, right: pad, bottom: pad }
+        }
       };
       onCommit(anno);
       setVertices([]);
@@ -2062,8 +2794,10 @@ const polygonHandlerFactory = {
       if (vertices.length === 0 || !currentPos) return null;
       const defaults = getDefaults();
       if (!defaults) return null;
+      const intensity = defaults.cloudyBorderIntensity ?? 0;
+      const pad = intensity > 0 ? getCloudyBorderExtent(intensity, defaults.strokeWidth, false) : defaults.strokeWidth / 2;
       const allPoints = [...vertices, currentPos];
-      const bounds = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
+      const bounds = expandRect(rectFromPoints(allPoints), pad);
       return {
         type: PdfAnnotationSubtype.POLYGON,
         bounds,
@@ -2149,10 +2883,11 @@ const squareHandlerFactory = {
         const x = clamp(pos.x - halfWidth, 0, pageSize.width - width);
         const y = clamp(pos.y - halfHeight, 0, pageSize.height - height);
         const strokeWidth = defaults.strokeWidth;
-        const halfStroke = strokeWidth / 2;
+        const intensity = defaults.cloudyBorderIntensity ?? 0;
+        const pad = intensity > 0 ? getCloudyBorderExtent(intensity, strokeWidth, false) : strokeWidth / 2;
         const rect = {
-          origin: { x: x - halfStroke, y: y - halfStroke },
-          size: { width: width + strokeWidth, height: height + strokeWidth }
+          origin: { x: x - pad, y: y - pad },
+          size: { width: width + 2 * pad, height: height + 2 * pad }
         };
         const anno = {
           ...defaults,
@@ -2160,7 +2895,10 @@ const squareHandlerFactory = {
           created: /* @__PURE__ */ new Date(),
           id: uuidV4(),
           pageIndex,
-          rect
+          rect,
+          ...intensity > 0 && {
+            rectangleDifferences: { left: pad, top: pad, right: pad, bottom: pad }
+          }
         };
         onCommit(anno);
       }
@@ -2175,17 +2913,21 @@ const squareHandlerFactory = {
       const defaults = getDefaults();
       if (!defaults) return null;
       const strokeWidth = defaults.strokeWidth;
-      const halfStroke = strokeWidth / 2;
+      const intensity = defaults.cloudyBorderIntensity ?? 0;
+      const pad = intensity > 0 ? getCloudyBorderExtent(intensity, strokeWidth, false) : strokeWidth / 2;
       const rect = {
-        origin: { x: minX - halfStroke, y: minY - halfStroke },
-        size: { width: width + strokeWidth, height: height + strokeWidth }
+        origin: { x: minX - pad, y: minY - pad },
+        size: { width: width + 2 * pad, height: height + 2 * pad }
       };
       return {
         type: PdfAnnotationSubtype.SQUARE,
         bounds: rect,
         data: {
           rect,
-          ...defaults
+          ...defaults,
+          ...intensity > 0 && {
+            rectangleDifferences: { left: pad, top: pad, right: pad, bottom: pad }
+          }
         }
       };
     };
@@ -2219,13 +2961,18 @@ const squareHandlerFactory = {
           if (!defaults2) return;
           const preview = getPreview(clampedPos);
           if (preview) {
+            const intensity = defaults2.cloudyBorderIntensity ?? 0;
+            const pad = intensity > 0 ? getCloudyBorderExtent(intensity, defaults2.strokeWidth, false) : void 0;
             const anno = {
               ...defaults2,
               type: PdfAnnotationSubtype.SQUARE,
               created: /* @__PURE__ */ new Date(),
               id: uuidV4(),
               pageIndex,
-              rect: preview.data.rect
+              rect: preview.data.rect,
+              ...pad !== void 0 && {
+                rectangleDifferences: { left: pad, top: pad, right: pad, bottom: pad }
+              }
             };
             onCommit(anno);
           }
@@ -2349,10 +3096,11 @@ const circleHandlerFactory = {
         const x = clamp(pos.x - halfWidth, 0, pageSize.width - width);
         const y = clamp(pos.y - halfHeight, 0, pageSize.height - height);
         const strokeWidth = defaults.strokeWidth;
-        const halfStroke = strokeWidth / 2;
+        const intensity = defaults.cloudyBorderIntensity ?? 0;
+        const pad = intensity > 0 ? getCloudyBorderExtent(intensity, strokeWidth, true) : strokeWidth / 2;
         const rect = {
-          origin: { x: x - halfStroke, y: y - halfStroke },
-          size: { width: width + strokeWidth, height: height + strokeWidth }
+          origin: { x: x - pad, y: y - pad },
+          size: { width: width + 2 * pad, height: height + 2 * pad }
         };
         const anno = {
           ...defaults,
@@ -2360,7 +3108,10 @@ const circleHandlerFactory = {
           created: /* @__PURE__ */ new Date(),
           id: uuidV4(),
           pageIndex,
-          rect
+          rect,
+          ...intensity > 0 && {
+            rectangleDifferences: { left: pad, top: pad, right: pad, bottom: pad }
+          }
         };
         onCommit(anno);
       }
@@ -2375,17 +3126,21 @@ const circleHandlerFactory = {
       const defaults = getDefaults();
       if (!defaults) return null;
       const strokeWidth = defaults.strokeWidth;
-      const halfStroke = strokeWidth / 2;
+      const intensity = defaults.cloudyBorderIntensity ?? 0;
+      const pad = intensity > 0 ? getCloudyBorderExtent(intensity, strokeWidth, true) : strokeWidth / 2;
       const rect = {
-        origin: { x: minX - halfStroke, y: minY - halfStroke },
-        size: { width: width + strokeWidth, height: height + strokeWidth }
+        origin: { x: minX - pad, y: minY - pad },
+        size: { width: width + 2 * pad, height: height + 2 * pad }
       };
       return {
         type: PdfAnnotationSubtype.CIRCLE,
         bounds: rect,
         data: {
           rect,
-          ...defaults
+          ...defaults,
+          ...intensity > 0 && {
+            rectangleDifferences: { left: pad, top: pad, right: pad, bottom: pad }
+          }
         }
       };
     };
@@ -2419,6 +3174,8 @@ const circleHandlerFactory = {
           if (!defaults2) return;
           const preview = getPreview(clampedPos);
           if (preview) {
+            const intensity = defaults2.cloudyBorderIntensity ?? 0;
+            const pad = intensity > 0 ? getCloudyBorderExtent(intensity, defaults2.strokeWidth, true) : void 0;
             const anno = {
               ...defaults2,
               type: PdfAnnotationSubtype.CIRCLE,
@@ -2426,7 +3183,10 @@ const circleHandlerFactory = {
               created: /* @__PURE__ */ new Date(),
               id: uuidV4(),
               pageIndex,
-              rect: preview.data.rect
+              rect: preview.data.rect,
+              ...pad !== void 0 && {
+                rectangleDifferences: { left: pad, top: pad, right: pad, bottom: pad }
+              }
             };
             onCommit(anno);
           }
@@ -2453,6 +3213,135 @@ const circleHandlerFactory = {
     };
   }
 };
+const textMarkupSelectionHandler = {
+  toolId: "__textMarkup__",
+  handle(context, selections, getText) {
+    const tool = context.getTool();
+    if (!tool) return;
+    for (const selection of selections) {
+      const id = uuidV4();
+      getText().then((text) => {
+        var _a;
+        context.createAnnotation(selection.pageIndex, {
+          ...tool.defaults,
+          rect: selection.rect,
+          segmentRects: selection.segmentRects,
+          pageIndex: selection.pageIndex,
+          created: /* @__PURE__ */ new Date(),
+          id,
+          ...text != null && { custom: { text } }
+        });
+        if ((_a = tool.behavior) == null ? void 0 : _a.selectAfterCreate) {
+          context.selectAnnotation(selection.pageIndex, id);
+        }
+      });
+    }
+  }
+};
+function computeCaretRect(lastSegRect) {
+  const lineHeight = lastSegRect.size.height;
+  const height = lineHeight / 2;
+  const width = height;
+  const lineEndX = lastSegRect.origin.x + lastSegRect.size.width;
+  return {
+    origin: {
+      x: lineEndX - width / 2,
+      y: lastSegRect.origin.y + lineHeight / 2
+    },
+    size: { width, height }
+  };
+}
+const insertTextSelectionHandler = {
+  toolId: "insertText",
+  handle(context, selections, getText) {
+    const tool = context.getTool();
+    if (!tool) return;
+    const getDefaults = () => ({
+      strokeColor: tool.defaults.strokeColor ?? "#E44234",
+      opacity: tool.defaults.opacity ?? 1,
+      flags: tool.defaults.flags ?? ["print"]
+    });
+    for (const selection of selections) {
+      const lastSegRect = selection.segmentRects[selection.segmentRects.length - 1];
+      if (!lastSegRect) continue;
+      const caretRect = computeCaretRect(lastSegRect);
+      const caretId = uuidV4();
+      const defaults = getDefaults();
+      getText().then((text) => {
+        var _a;
+        context.createAnnotation(selection.pageIndex, {
+          type: PdfAnnotationSubtype.CARET,
+          id: caretId,
+          pageIndex: selection.pageIndex,
+          rect: caretRect,
+          strokeColor: defaults.strokeColor,
+          opacity: defaults.opacity,
+          intent: "Insert",
+          rectangleDifferences: { left: 0.5, top: 0.5, right: 0.5, bottom: 0.5 },
+          created: /* @__PURE__ */ new Date(),
+          flags: defaults.flags,
+          ...text != null && { custom: { text } }
+        });
+        if ((_a = tool.behavior) == null ? void 0 : _a.selectAfterCreate) {
+          context.selectAnnotation(selection.pageIndex, caretId);
+        }
+      });
+    }
+  }
+};
+const replaceTextSelectionHandler = {
+  toolId: "replaceText",
+  handle(context, selections, getText) {
+    const tool = context.getTool();
+    if (!tool) return;
+    const getDefaults = () => ({
+      strokeColor: tool.defaults.strokeColor ?? "#E44234",
+      opacity: tool.defaults.opacity ?? 1,
+      flags: tool.defaults.flags ?? ["print"]
+    });
+    for (const selection of selections) {
+      const lastSegRect = selection.segmentRects[selection.segmentRects.length - 1];
+      if (!lastSegRect) continue;
+      const caretRect = computeCaretRect(lastSegRect);
+      const caretId = uuidV4();
+      const strikeoutId = uuidV4();
+      const defaults = getDefaults();
+      getText().then((text) => {
+        var _a;
+        context.createAnnotation(selection.pageIndex, {
+          type: PdfAnnotationSubtype.CARET,
+          id: caretId,
+          pageIndex: selection.pageIndex,
+          rect: caretRect,
+          strokeColor: defaults.strokeColor,
+          opacity: defaults.opacity,
+          intent: "Replace",
+          rectangleDifferences: { left: 0.5, top: 0.5, right: 0.5, bottom: 0.5 },
+          created: /* @__PURE__ */ new Date(),
+          flags: defaults.flags
+        });
+        context.createAnnotation(selection.pageIndex, {
+          type: PdfAnnotationSubtype.STRIKEOUT,
+          id: strikeoutId,
+          pageIndex: selection.pageIndex,
+          rect: selection.rect,
+          segmentRects: selection.segmentRects,
+          strokeColor: defaults.strokeColor,
+          opacity: defaults.opacity,
+          intent: "StrikeOutTextEdit",
+          inReplyToId: caretId,
+          replyType: PdfAnnotationReplyType.Group,
+          created: /* @__PURE__ */ new Date(),
+          flags: defaults.flags,
+          ...text != null && { custom: { text } }
+        });
+        if ((_a = tool.behavior) == null ? void 0 : _a.selectAfterCreate) {
+          context.selectAnnotation(selection.pageIndex, caretId);
+        }
+      });
+    }
+  }
+};
 const patchInk = (original, ctx) => {
   switch (ctx.type) {
     case "vertex-edit":
@@ -2469,23 +3358,29 @@ const patchInk = (original, ctx) => {
     }
     case "resize": {
       if (!ctx.changes.rect) return ctx.changes;
-      const { oldRect, resolvedRect, rects } = baseResizeScaling(
+      const { scaleX, scaleY, oldRect, resolvedRect, rects } = baseResizeScaling(
         original,
         ctx.changes.rect,
         ctx.metadata
       );
-      const inset = (r, pad) => ({
-        origin: { x: r.origin.x + pad, y: r.origin.y + pad },
+      const inset = (r2, pad) => ({
+        origin: { x: r2.origin.x + pad, y: r2.origin.y + pad },
         size: {
-          width: Math.max(1, r.size.width - pad * 2),
-          height: Math.max(1, r.size.height - pad * 2)
+          width: Math.max(1, r2.size.width - pad * 2),
+          height: Math.max(1, r2.size.height - pad * 2)
         }
       });
-      const strokeScale = Math.min(
-        resolvedRect.size.width / oldRect.size.width,
-        resolvedRect.size.height / oldRect.size.height
+      const resizeEpsilon = 1e-3;
+      const widthChanged = Math.abs(scaleX - 1) > resizeEpsilon;
+      const heightChanged = Math.abs(scaleY - 1) > resizeEpsilon;
+      const strokeScale = widthChanged && !heightChanged ? scaleX : !widthChanged && heightChanged ? scaleY : Math.min(scaleX, scaleY);
+      const rawStrokeWidth = Math.max(1, original.strokeWidth * strokeScale);
+      const maxStrokeWidth = Math.max(
+        1,
+        Math.min(resolvedRect.size.width, resolvedRect.size.height)
       );
-      const newStrokeWidth = Math.max(1, Math.round(original.strokeWidth * strokeScale));
+      const clampedStrokeWidth = Math.min(rawStrokeWidth, maxStrokeWidth);
+      const newStrokeWidth = Number(clampedStrokeWidth.toFixed(1));
       const innerOld = inset(oldRect, original.strokeWidth / 2);
       const innerNew = inset(resolvedRect, newStrokeWidth / 2);
       const sx = innerNew.size.width / Math.max(innerOld.size.width, 1e-6);
@@ -2695,11 +3590,17 @@ const patchPolyline = (orig, ctx) => {
       return ctx.changes;
   }
 };
+function getPolygonPad(intensity, strokeWidth) {
+  if ((intensity ?? 0) > 0) {
+    return getCloudyBorderExtent(intensity, strokeWidth, false);
+  }
+  return strokeWidth / 2;
+}
 const patchPolygon = (orig, ctx) => {
   switch (ctx.type) {
     case "vertex-edit":
       if (ctx.changes.vertices && ctx.changes.vertices.length) {
-        const pad = orig.strokeWidth / 2;
+        const pad = getPolygonPad(orig.cloudyBorderIntensity, orig.strokeWidth);
         const rawVertices = ctx.changes.vertices;
         const rawRect = expandRect(rectFromPoints(rawVertices), pad);
         const compensated = compensateRotatedVertexEdit(orig, rawVertices, rawRect);
@@ -2743,15 +3644,30 @@ const patchPolygon = (orig, ctx) => {
       };
     }
     case "property-update": {
-      const needsRectUpdate = ctx.changes.strokeWidth !== void 0 || ctx.changes.rotation !== void 0;
+      const cloudyChanged = ctx.changes.cloudyBorderIntensity !== void 0;
+      const needsRectUpdate = ctx.changes.strokeWidth !== void 0 || ctx.changes.rotation !== void 0 || cloudyChanged;
       if (!needsRectUpdate) return ctx.changes;
       const merged = { ...orig, ...ctx.changes };
-      const pad = merged.strokeWidth / 2;
+      const pad = getPolygonPad(merged.cloudyBorderIntensity, merged.strokeWidth);
       const tightRect = expandRect(rectFromPoints(merged.vertices), pad);
+      let patch = ctx.changes;
+      const hasCloudy = (orig.cloudyBorderIntensity ?? 0) > 0;
+      if (cloudyChanged || ctx.changes.strokeWidth !== void 0 && hasCloudy) {
+        const intensity = merged.cloudyBorderIntensity ?? 0;
+        if (intensity > 0) {
+          const extent = getCloudyBorderExtent(intensity, merged.strokeWidth, false);
+          patch = {
+            ...patch,
+            rectangleDifferences: { left: extent, top: extent, right: extent, bottom: extent }
+          };
+        } else {
+          patch = { ...patch, rectangleDifferences: void 0 };
+        }
+      }
       const effectiveRotation = ctx.changes.rotation ?? orig.rotation ?? 0;
       if (orig.unrotatedRect || ctx.changes.rotation !== void 0) {
         return {
-          ...ctx.changes,
+          ...patch,
           unrotatedRect: tightRect,
           rect: calculateRotatedRectAABBAroundPoint(
             tightRect,
@@ -2760,7 +3676,7 @@ const patchPolygon = (orig, ctx) => {
           )
         };
       }
-      return { ...ctx.changes, rect: tightRect };
+      return { ...patch, rect: tightRect };
     }
     default:
       return ctx.changes;
@@ -2776,11 +3692,29 @@ const patchCircle = (orig, ctx) => {
       return baseResizeScaling(orig, ctx.changes.rect, ctx.metadata).rects;
     case "rotate":
       return baseRotateChanges(orig, ctx) ?? ctx.changes;
-    case "property-update":
+    case "property-update": {
+      let patch = ctx.changes;
+      const cloudyChanged = ctx.changes.cloudyBorderIntensity !== void 0;
+      const strokeChanged = ctx.changes.strokeWidth !== void 0;
+      const hasCloudy = (orig.cloudyBorderIntensity ?? 0) > 0;
+      if (cloudyChanged || strokeChanged && hasCloudy) {
+        const merged = { ...orig, ...ctx.changes };
+        const intensity = merged.cloudyBorderIntensity ?? 0;
+        if (intensity > 0) {
+          const extent = getCloudyBorderExtent(intensity, merged.strokeWidth, true);
+          patch = {
+            ...patch,
+            rectangleDifferences: { left: extent, top: extent, right: extent, bottom: extent }
+          };
+        } else {
+          patch = { ...patch, rectangleDifferences: void 0 };
+        }
+      }
       if (ctx.changes.rotation !== void 0) {
-        return { ...ctx.changes, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
+        patch = { ...patch, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
       }
-      return ctx.changes;
+      return patch;
+    }
     default:
       return ctx.changes;
   }
@@ -2795,11 +3729,29 @@ const patchSquare = (orig, ctx) => {
       return baseResizeScaling(orig, ctx.changes.rect, ctx.metadata).rects;
     case "rotate":
       return baseRotateChanges(orig, ctx) ?? ctx.changes;
-    case "property-update":
+    case "property-update": {
+      let patch = ctx.changes;
+      const cloudyChanged = ctx.changes.cloudyBorderIntensity !== void 0;
+      const strokeChanged = ctx.changes.strokeWidth !== void 0;
+      const hasCloudy = (orig.cloudyBorderIntensity ?? 0) > 0;
+      if (cloudyChanged || strokeChanged && hasCloudy) {
+        const merged = { ...orig, ...ctx.changes };
+        const intensity = merged.cloudyBorderIntensity ?? 0;
+        if (intensity > 0) {
+          const extent = getCloudyBorderExtent(intensity, merged.strokeWidth, false);
+          patch = {
+            ...patch,
+            rectangleDifferences: { left: extent, top: extent, right: extent, bottom: extent }
+          };
+        } else {
+          patch = { ...patch, rectangleDifferences: void 0 };
+        }
+      }
       if (ctx.changes.rotation !== void 0) {
-        return { ...ctx.changes, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
+        patch = { ...patch, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
       }
-      return ctx.changes;
+      return patch;
+    }
     default:
       return ctx.changes;
   }
@@ -2842,34 +3794,6 @@ const patchStamp = (orig, ctx) => {
       return ctx.changes;
   }
 };
-function convertAABBRectToUnrotatedSpace(newAABBRect, originalAABBRect, originalUnrotatedRect, rotationDegrees) {
-  const theta = rotationDegrees * Math.PI / 180;
-  const A = Math.abs(Math.cos(theta));
-  const B = Math.abs(Math.sin(theta));
-  const det = A * A - B * B;
-  const newAABBw = newAABBRect.size.width;
-  const newAABBh = newAABBRect.size.height;
-  let newWidth;
-  let newHeight;
-  if (Math.abs(det) > 1e-6) {
-    newWidth = (A * newAABBw - B * newAABBh) / det;
-    newHeight = (A * newAABBh - B * newAABBw) / det;
-    newWidth = Math.max(newWidth, 1);
-    newHeight = Math.max(newHeight, 1);
-  } else {
-    const origArea = originalAABBRect.size.width * originalAABBRect.size.height;
-    const newArea = newAABBw * newAABBh;
-    const uniformScale = origArea > 0 ? Math.sqrt(newArea / origArea) : 1;
-    newWidth = originalUnrotatedRect.size.width * uniformScale;
-    newHeight = originalUnrotatedRect.size.height * uniformScale;
-  }
-  const newCenterX = newAABBRect.origin.x + newAABBw / 2;
-  const newCenterY = newAABBRect.origin.y + newAABBh / 2;
-  return {
-    origin: { x: newCenterX - newWidth / 2, y: newCenterY - newHeight / 2 },
-    size: { width: newWidth, height: newHeight }
-  };
-}
 const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
   constructor(id, registry, config) {
     var _a, _b, _c;
@@ -2881,6 +3805,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     this.importQueue = /* @__PURE__ */ new Map();
     this.commitInProgress = /* @__PURE__ */ new Map();
     this.handlerFactories = /* @__PURE__ */ new Map();
+    this.selectionHandlerFactories = /* @__PURE__ */ new Map();
     this.activeTool$ = createBehaviorEmitter();
     this.events$ = createBehaviorEmitter();
     this.toolsChange$ = createBehaviorEmitter();
@@ -2897,6 +3822,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     this.history = ((_b = registry.getPlugin("history")) == null ? void 0 : _b.provides()) ?? null;
     this.interactionManager = ((_c = registry.getPlugin("interaction-manager")) == null ? void 0 : _c.provides()) ?? null;
     this.registerHandlerFactories();
+    this.registerSelectionHandlerFactories();
     this.registerBuiltInPatches();
   }
   // ─────────────────────────────────────────────────────────
@@ -2922,7 +3848,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       for (const tool of this.state.tools) {
         if (tool.interaction.textSelection) {
           this.selection.enableForMode(tool.interaction.mode ?? tool.id, {
-            showSelectionRects: false,
+            showSelectionRects: tool.interaction.showSelectionRects ?? false,
             enableSelection: true,
             enableMarquee: false
           });
@@ -2951,6 +3877,11 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     this.handlerFactories.set(PdfAnnotationSubtype.LINE, lineHandlerFactory);
     this.handlerFactories.set(PdfAnnotationSubtype.INK, inkHandlerFactory);
     this.handlerFactories.set(PdfAnnotationSubtype.FREETEXT, freeTextHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.TEXT, textHandlerFactory);
+  }
+  registerSelectionHandlerFactories() {
+    this.selectionHandlerFactories.set("insertText", insertTextSelectionHandler);
+    this.selectionHandlerFactories.set("replaceText", replaceTextSelectionHandler);
   }
   registerBuiltInPatches() {
     this.patchRegistry.register(PdfAnnotationSubtype.INK, patchInk);
@@ -2984,7 +3915,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       if (modeId !== "pointerMode") return;
       const docState = this.state.documents[documentId];
       if (!docState) return;
-      const pageAnnotations = (docState.pages[pageIndex] ?? []).map((uid) => docState.byUid[uid]).filter((ta) => ta !== void 0).filter((ta) => !isLink(ta));
+      const pageAnnotations = (docState.pages[pageIndex] ?? []).map((uid) => docState.byUid[uid]).filter((ta) => ta !== void 0).filter((ta) => isSidebarAnnotation(ta));
       const selectedIds = pageAnnotations.filter((ta) => rectsIntersect(rect, ta.object.rect)).map((ta) => ta.object.id);
       if (selectedIds.length > 0) {
         const expandedIds = /* @__PURE__ */ new Set();
@@ -3002,44 +3933,32 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       }
     });
     (_c = this.selection) == null ? void 0 : _c.onEndSelection(({ documentId }) => {
-      var _a2, _b2, _c2;
-      if (!this.checkPermission(documentId, PdfPermissionFlag.ModifyAnnotations)) {
-        return;
-      }
+      var _a2, _b2, _c2, _d;
+      if (!this.checkPermission(documentId, PdfPermissionFlag.ModifyAnnotations)) return;
       const activeTool = this.getActiveTool(documentId);
       if (!activeTool || !activeTool.interaction.textSelection) return;
       const formattedSelection = (_a2 = this.selection) == null ? void 0 : _a2.getFormattedSelection();
       const selectionText = (_b2 = this.selection) == null ? void 0 : _b2.getSelectedText();
       if (!formattedSelection || !selectionText) return;
-      for (const selection of formattedSelection) {
-        selectionText.wait((text) => {
-          var _a3, _b3;
-          const annotationId = uuidV4();
-          this.createAnnotation(
-            selection.pageIndex,
-            {
-              ...activeTool.defaults,
-              rect: selection.rect,
-              segmentRects: selection.segmentRects,
-              pageIndex: selection.pageIndex,
-              created: /* @__PURE__ */ new Date(),
-              id: annotationId,
-              custom: {
-                text: text.join("\n")
-              }
-            },
-            void 0,
-            documentId
-          );
-          if ((_a3 = activeTool.behavior) == null ? void 0 : _a3.deactivateToolAfterCreate) {
-            this.setActiveTool(null, documentId);
-          }
-          if ((_b3 = activeTool.behavior) == null ? void 0 : _b3.selectAfterCreate) {
-            this.selectAnnotation(selection.pageIndex, annotationId, documentId);
-          }
-        }, ignore);
+      const getText = () => new Promise((resolve) => {
+        selectionText.wait(
+          (text) => resolve(text.join("\n")),
+          () => resolve(void 0)
+        );
+      });
+      const context = {
+        toolId: activeTool.id,
+        documentId,
+        getTool: () => this.getActiveTool(documentId) ?? null,
+        createAnnotation: (pageIndex, annotation) => this.createAnnotation(pageIndex, annotation, void 0, documentId),
+        selectAnnotation: (pageIndex, id) => this.selectAnnotation(pageIndex, id, documentId)
+      };
+      const handler = this.selectionHandlerFactories.get(activeTool.id) ?? textMarkupSelectionHandler;
+      handler.handle(context, formattedSelection, getText);
+      if ((_c2 = activeTool.behavior) == null ? void 0 : _c2.deactivateToolAfterCreate) {
+        this.setActiveTool(null, documentId);
       }
-      (_c2 = this.selection) == null ? void 0 : _c2.clear();
+      (_d = this.selection) == null ? void 0 : _d.clear();
     });
   }
   registerInteractionForTool(tool) {
@@ -4867,6 +5786,8 @@ const isPolylineTool = createToolPredicate("polyline");
 const isPolygonTool = createToolPredicate("polygon");
 const isFreeTextTool = createToolPredicate("freeText");
 const isStampTool = createToolPredicate("stamp");
+const isInsertTextTool = createToolPredicate("insertText");
+const isReplaceTextTool = createToolPredicate("replaceText");
 const AnnotationPluginPackage = {
   manifest,
   create: (registry, config) => new AnnotationPlugin(ANNOTATION_PLUGIN_ID, registry, config),
@@ -4881,10 +5802,14 @@ export {
   calculateRotatedRectAABBAroundPoint2 as calculateRotatedRectAABBAroundPoint,
   convertAABBRectToUnrotatedSpace,
   createToolPredicate,
+  generateCloudyEllipsePath,
+  generateCloudyPolygonPath,
+  generateCloudyRectanglePath,
   getAnnotationByUid,
   getAnnotations,
   getAnnotationsByPageIndex,
   getAttachedLinks,
+  getCloudyBorderExtent,
   getGroupLeaderId,
   getGroupMembers,
   getIRTChildIds,
@@ -4906,6 +5831,7 @@ export {
   initialDocumentState,
   initialState,
   isAnnotationSelected,
+  isCaret,
   isCircle,
   isCircleTool,
   isFreeText,
@@ -4916,6 +5842,7 @@ export {
   isInk,
   isInkHighlighterTool,
   isInkTool,
+  isInsertTextTool,
   isLine,
   isLineTool,
   isLink,
@@ -4924,6 +5851,7 @@ export {
   isPolyline,
   isPolylineTool,
   isRedact,
+  isReplaceTextTool,
   isSidebarAnnotation,
   isSquare,
   isSquareTool,