@embedpdf/plugin-annotation 2.8.0 → 2.9.0

package/dist/index.js

@@ -340,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
   {
@@ -482,52 +538,7 @@ const defaultTools = [
     }
   },
   // Drawing Tools
-  {
-    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
-    }
-  },
-  {
-    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 r = ((a.rotation ?? 0) % 90 + 90) % 90;
-        return r >= 6 && r <= 84;
-      }
-    },
-    defaults: {
-      type: PdfAnnotationSubtype.INK,
-      intent: "InkHighlight",
-      strokeColor: "#FFCD45",
-      color: "#FFCD45",
-      // deprecated alias
-      opacity: 1,
-      strokeWidth: 14,
-      blendMode: PdfBlendMode.Multiply
-    }
-  },
+  ...inkTools,
   // Shape Tools
   {
     id: "circle",
@@ -540,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: {
@@ -568,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: {
@@ -599,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: {
@@ -630,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: {
@@ -666,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: {
@@ -692,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: {
@@ -736,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: {
@@ -1180,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) {
@@ -1215,7 +1238,8 @@ const inkHandlerFactory = {
         data: {
           ...defaults,
           rect: bounds,
-          inkList: strokes
+          inkList: strokes,
+          blendMode: defaults.blendMode
         }
       };
     };
@@ -1243,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();
@@ -1263,7 +1318,7 @@ const inkHandlerFactory = {
           }
           setStrokes([]);
           onPreview(null);
-        }, 800);
+        }, commitDelay);
       },
       onPointerCancel: (_, evt) => {
         var _a;
@@ -1335,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,
@@ -1484,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),
@@ -1701,8 +1756,8 @@ function useClickDetector({
     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) {
+      const distance2 = Math.sqrt(Math.pow(pos.x - start.x, 2) + Math.pow(pos.y - start.y, 2));
+      if (distance2 > threshold) {
         setHasMoved(true);
       }
     },
@@ -2127,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,
@@ -2165,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,
@@ -2173,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([]);
@@ -2186,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,
@@ -2273,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,
@@ -2284,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);
       }
@@ -2299,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 }
+          }
         }
       };
     };
@@ -2343,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);
           }
@@ -2473,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,
@@ -2484,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);
       }
@@ -2499,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 }
+          }
         }
       };
     };
@@ -2543,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,
@@ -2550,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);
           }
@@ -2722,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);
@@ -2948,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);
@@ -2996,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,
@@ -3013,7 +3676,7 @@ const patchPolygon = (orig, ctx) => {
           )
         };
       }
-      return { ...ctx.changes, rect: tightRect };
+      return { ...patch, rect: tightRect };
     }
     default:
       return ctx.changes;
@@ -3029,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;
   }
@@ -3048,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;
   }
@@ -3095,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;
@@ -5131,10 +5802,14 @@ export {
   calculateRotatedRectAABBAroundPoint2 as calculateRotatedRectAABBAroundPoint,
   convertAABBRectToUnrotatedSpace,
   createToolPredicate,
+  generateCloudyEllipsePath,
+  generateCloudyPolygonPath,
+  generateCloudyRectanglePath,
   getAnnotationByUid,
   getAnnotations,
   getAnnotationsByPageIndex,
   getAttachedLinks,
+  getCloudyBorderExtent,
   getGroupLeaderId,
   getGroupMembers,
   getIRTChildIds,