@embedpdf/plugin-annotation 2.5.0 → 2.6.1

package/dist/index.js

@@ -1,5 +1,6 @@
 import { clamp, BasePlugin, createBehaviorEmitter } from "@embedpdf/core";
-import { PdfAnnotationSubtype, PdfAnnotationReplyType, PdfBlendMode, PdfAnnotationBorderStyle, PdfAnnotationLineEnding, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, expandRect, rectFromPoints, uuidV4, rotateAndTranslatePoint, PdfAnnotationIcon, PdfPermissionFlag, ignore, PdfTaskHelper, PdfErrorCode, Task, TaskStage } from "@embedpdf/models";
+import { PdfAnnotationSubtype, PdfAnnotationReplyType, PdfBlendMode, PdfAnnotationBorderStyle, PdfAnnotationLineEnding, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, expandRect, rectFromPoints, uuidV4, getRectCenter, inferRotationCenterFromRects, calculateRotatedRectAABBAroundPoint, rotateAndTranslatePoint, calculateRotatedRectAABB, rotatePointAround, rotateVertices, PdfAnnotationIcon, PdfPermissionFlag, ignore, PdfTaskHelper, PdfErrorCode, Task, TaskStage } from "@embedpdf/models";
+import { calculateRotatedRectAABB as calculateRotatedRectAABB2, calculateRotatedRectAABBAroundPoint as calculateRotatedRectAABBAroundPoint2, getRectCenter as getRectCenter2, inferRotationCenterFromRects as inferRotationCenterFromRects2, rotatePointAround as rotatePointAround2, rotateVertices as rotateVertices2 } from "@embedpdf/models";
 const ANNOTATION_PLUGIN_ID = "annotation";
 const manifest = {
   id: ANNOTATION_PLUGIN_ID,
@@ -431,7 +432,11 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: true,
-      lockAspectRatio: false
+      lockAspectRatio: false,
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.INK,
@@ -454,7 +459,11 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: true,
-      lockAspectRatio: false
+      lockAspectRatio: false,
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.CIRCLE,
@@ -478,7 +487,11 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: true,
-      lockAspectRatio: false
+      lockAspectRatio: false,
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.SQUARE,
@@ -504,8 +517,12 @@ const defaultTools = [
       isResizable: false,
       // Uses vertex editing when selected individually
       lockAspectRatio: false,
-      isGroupResizable: true
+      isGroupResizable: true,
       // Scales proportionally in a group
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.LINE,
@@ -531,8 +548,12 @@ const defaultTools = [
       isResizable: false,
       // Uses vertex editing when selected individually
       lockAspectRatio: false,
-      isGroupResizable: true
+      isGroupResizable: true,
       // Scales proportionally in a group
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.LINE,
@@ -563,8 +584,12 @@ const defaultTools = [
       isResizable: false,
       // Uses vertex editing when selected individually
       lockAspectRatio: false,
-      isGroupResizable: true
+      isGroupResizable: true,
       // Scales proportionally in a group
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.POLYLINE,
@@ -585,8 +610,12 @@ const defaultTools = [
       isResizable: false,
       // Uses vertex editing when selected individually
       lockAspectRatio: false,
-      isGroupResizable: true
+      isGroupResizable: true,
       // Scales proportionally in a group
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.POLYGON,
@@ -606,7 +635,11 @@ const defaultTools = [
       cursor: "crosshair",
       isDraggable: true,
       isResizable: true,
-      lockAspectRatio: false
+      lockAspectRatio: false,
+      lockGroupAspectRatio: (a) => {
+        const r = ((a.rotation ?? 0) % 90 + 90) % 90;
+        return r >= 6 && r <= 84;
+      }
     },
     defaults: {
       type: PdfAnnotationSubtype.FREETEXT,
@@ -626,6 +659,9 @@ const defaultTools = [
       enabled: true,
       defaultSize: { width: 100, height: 20 },
       defaultContent: "Insert text"
+    },
+    behavior: {
+      insertUpright: true
     }
   },
   {
@@ -637,11 +673,15 @@ const defaultTools = [
       cursor: "copy",
       isDraggable: true,
       isResizable: true,
-      lockAspectRatio: true
+      lockAspectRatio: true,
+      lockGroupAspectRatio: true
     },
     defaults: {
       type: PdfAnnotationSubtype.STAMP
       // No imageSrc by default, which tells the UI to open a file picker
+    },
+    behavior: {
+      insertUpright: true
     }
   }
 ];
@@ -683,14 +723,44 @@ const patchAnno = (docState, uid, patch) => {
   };
 };
 const initialState = (cfg) => {
-  const toolMap = /* @__PURE__ */ new Map();
-  defaultTools.forEach((t) => toolMap.set(t.id, t));
-  (cfg.tools || []).forEach((t) => toolMap.set(t.id, t));
+  const defaultMap = /* @__PURE__ */ new Map();
+  defaultTools.forEach((t) => defaultMap.set(t.id, t));
+  const toolMap = new Map(defaultMap);
+  (cfg.tools || []).forEach((userTool) => {
+    const base = defaultMap.get(userTool.id);
+    if (base) {
+      toolMap.set(userTool.id, {
+        ...base,
+        ...userTool,
+        defaults: { ...base.defaults, ...userTool.defaults },
+        interaction: { ...base.interaction, ...userTool.interaction },
+        behavior: { ...base.behavior, ...userTool.behavior },
+        ...base.clickBehavior || userTool.clickBehavior ? {
+          clickBehavior: {
+            ...base.clickBehavior,
+            ...userTool.clickBehavior
+          }
+        } : {}
+      });
+    } else {
+      toolMap.set(userTool.id, userTool);
+    }
+  });
+  const tools = Array.from(toolMap.values()).map((t) => {
+    var _a, _b;
+    return {
+      ...t,
+      behavior: {
+        ...t.behavior,
+        deactivateToolAfterCreate: ((_a = t.behavior) == null ? void 0 : _a.deactivateToolAfterCreate) ?? cfg.deactivateToolAfterCreate ?? false,
+        selectAfterCreate: ((_b = t.behavior) == null ? void 0 : _b.selectAfterCreate) ?? cfg.selectAfterCreate ?? true
+      }
+    };
+  });
   return {
     documents: {},
     activeDocumentId: null,
-    // `Array.from(toolMap.values())` now correctly returns `AnnotationTool[]`, which matches the state's type.
-    tools: Array.from(toolMap.values()),
+    tools,
     colorPresets: cfg.colorPresets ?? DEFAULT_COLORS
   };
 };
@@ -1115,149 +1185,6 @@ function useClickDetector({
     }
   };
 }
-const freeTextHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.FREETEXT,
-  create(context) {
-    const { onCommit, onPreview, getTool, pageSize, pageIndex } = context;
-    const [getStart, setStart] = useState(null);
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        fontColor: tool.defaults.fontColor ?? "#000000",
-        opacity: tool.defaults.opacity ?? 1,
-        fontSize: tool.defaults.fontSize ?? 12,
-        fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
-        color: tool.defaults.color ?? tool.defaults.backgroundColor ?? "transparent",
-        textAlign: tool.defaults.textAlign ?? PdfTextAlignment.Left,
-        verticalAlign: tool.defaults.verticalAlign ?? PdfVerticalAlignment.Top,
-        contents: tool.defaults.contents ?? "Insert text here",
-        flags: tool.defaults.flags ?? ["print"]
-      };
-    };
-    const clickDetector = useClickDetector({
-      threshold: 5,
-      getTool,
-      onClickDetected: (pos, tool) => {
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const clickConfig = tool.clickBehavior;
-        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
-        const { width, height } = clickConfig.defaultSize;
-        const halfWidth = width / 2;
-        const halfHeight = height / 2;
-        const x = clamp(pos.x - halfWidth, 0, pageSize.width - width);
-        const y = clamp(pos.y - halfHeight, 0, pageSize.height - height);
-        const rect = {
-          origin: { x, y },
-          size: { width, height }
-        };
-        const contents = clickConfig.defaultContent ?? defaults.contents;
-        const anno = {
-          ...defaults,
-          contents,
-          type: PdfAnnotationSubtype.FREETEXT,
-          rect,
-          pageIndex,
-          id: uuidV4(),
-          created: /* @__PURE__ */ new Date()
-        };
-        onCommit(anno);
-      }
-    });
-    const getPreview = (current) => {
-      const start = getStart();
-      if (!start) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const minX = Math.min(start.x, current.x);
-      const minY = Math.min(start.y, current.y);
-      const width = Math.abs(start.x - current.x);
-      const height = Math.abs(start.y - current.y);
-      const rect = {
-        origin: { x: minX, y: minY },
-        size: { width, height }
-      };
-      return {
-        type: PdfAnnotationSubtype.FREETEXT,
-        bounds: rect,
-        data: {
-          ...defaults,
-          rect
-        }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setStart(clampedPos);
-        clickDetector.onStart(clampedPos);
-        onPreview(getPreview(clampedPos));
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        const clampedPos = clampToPage(pos);
-        clickDetector.onMove(clampedPos);
-        if (getStart() && clickDetector.hasMoved()) {
-          onPreview(getPreview(clampedPos));
-        }
-      },
-      onPointerUp: (pos, evt) => {
-        var _a;
-        const start = getStart();
-        if (!start) return;
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const clampedPos = clampToPage(pos);
-        if (!clickDetector.hasMoved()) {
-          clickDetector.onEnd(clampedPos);
-        } else {
-          const minX = Math.min(start.x, clampedPos.x);
-          const minY = Math.min(start.y, clampedPos.y);
-          const width = Math.abs(start.x - clampedPos.x);
-          const height = Math.abs(start.y - clampedPos.y);
-          const rect = {
-            origin: { x: minX, y: minY },
-            size: { width, height }
-          };
-          const anno = {
-            ...defaults,
-            type: PdfAnnotationSubtype.FREETEXT,
-            rect,
-            pageIndex: context.pageIndex,
-            id: uuidV4(),
-            created: /* @__PURE__ */ new Date()
-          };
-          onCommit(anno);
-        }
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerLeave: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
-};
 function createArrowHandler(isClosed) {
   const calculateGeometry = (sw) => {
     const len = sw * 9;
@@ -1373,6 +1300,13 @@ const LINE_ENDING_HANDLERS = {
   [PdfAnnotationLineEnding.Slash]: createLineHandler(18, (angle) => angle + Math.PI / 1.5)
 };
 const EXTRA_PADDING = 1.2;
+function calculateAABBFromVertices(vertices, padding = 0) {
+  if (vertices.length === 0) {
+    return { origin: { x: 0, y: 0 }, size: { width: 0, height: 0 } };
+  }
+  const baseRect = rectFromPoints(vertices);
+  return padding > 0 ? expandRect(baseRect, padding) : baseRect;
+}
 function lineRectWithEndings(vertices, strokeWidth, endings) {
   if (!vertices || vertices.length === 0) {
     return { origin: { x: 0, y: 0 }, size: { width: 0, height: 0 } };
@@ -1407,6 +1341,54 @@ function lineRectWithEndings(vertices, strokeWidth, endings) {
   const pad = strokeWidth / 2 + EXTRA_PADDING * strokeWidth;
   return expandRect(baseRect, pad);
 }
+function resolveVertexEditRects(original, tightRect) {
+  if (!original.unrotatedRect) return { rect: tightRect };
+  const center = getRectCenter(tightRect);
+  return {
+    rect: calculateRotatedRectAABBAroundPoint(tightRect, original.rotation ?? 0, center),
+    unrotatedRect: tightRect
+  };
+}
+function resolveAnnotationRotationCenter(original) {
+  if (!original.unrotatedRect) return getRectCenter(original.rect);
+  return inferRotationCenterFromRects(
+    original.unrotatedRect,
+    original.rect,
+    original.rotation ?? 0
+  );
+}
+function resolveRotateRects(original, nextUnrotatedRect, angleDegrees) {
+  const baseCenter = resolveAnnotationRotationCenter(original);
+  const baseRect = original.unrotatedRect ?? original.rect;
+  const translation = {
+    x: nextUnrotatedRect.origin.x - baseRect.origin.x,
+    y: nextUnrotatedRect.origin.y - baseRect.origin.y
+  };
+  const nextCenter = {
+    x: baseCenter.x + translation.x,
+    y: baseCenter.y + translation.y
+  };
+  return {
+    rect: calculateRotatedRectAABBAroundPoint(nextUnrotatedRect, angleDegrees, nextCenter),
+    unrotatedRect: nextUnrotatedRect
+  };
+}
+function compensateRotatedVertexEdit(original, vertices, tightRect) {
+  if (!original.unrotatedRect) return vertices;
+  const angle = original.rotation ?? 0;
+  if (Math.abs(angle % 360) < 1e-8) return vertices;
+  const baseCenter = resolveAnnotationRotationCenter(original);
+  const nextCenter = getRectCenter(tightRect);
+  const rad = angle * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  const dx = baseCenter.x - nextCenter.x;
+  const dy = baseCenter.y - nextCenter.y;
+  const qx = (1 - cos) * dx + sin * dy;
+  const qy = -sin * dx + (1 - cos) * dy;
+  if (Math.abs(qx) < 1e-8 && Math.abs(qy) < 1e-8) return vertices;
+  return vertices.map((v) => ({ x: v.x + qx, y: v.y + qy }));
+}
 function createEnding(ending, strokeWidth, rad, px, py) {
   if (!ending) return null;
   const handler = LINE_ENDING_HANDLERS[ending];
@@ -1439,14 +1421,298 @@ class PatchRegistry {
   }
 }
 const patchRegistry = new PatchRegistry();
+function baseRotateChanges(orig, ctx) {
+  var _a;
+  if (((_a = ctx.metadata) == null ? void 0 : _a.rotationAngle) === void 0) return null;
+  const angleDegrees = ctx.metadata.rotationAngle;
+  const baseUnrotatedRect = ctx.changes.unrotatedRect ?? orig.unrotatedRect ?? orig.rect;
+  const normalizedUnrotatedRect = {
+    origin: { ...baseUnrotatedRect.origin },
+    size: { ...baseUnrotatedRect.size }
+  };
+  return {
+    ...resolveRotateRects(orig, normalizedUnrotatedRect, angleDegrees),
+    rotation: angleDegrees
+  };
+}
+function basePropertyRotationChanges(orig, newRotation) {
+  const unrotatedRect = orig.unrotatedRect ?? orig.rect;
+  return {
+    rotation: newRotation,
+    ...resolveRotateRects(orig, unrotatedRect, newRotation)
+  };
+}
+function baseMoveChanges(orig, newRect) {
+  const dx = newRect.origin.x - orig.rect.origin.x;
+  const dy = newRect.origin.y - orig.rect.origin.y;
+  const rects = { rect: newRect };
+  if (orig.unrotatedRect) {
+    rects.unrotatedRect = {
+      origin: { x: orig.unrotatedRect.origin.x + dx, y: orig.unrotatedRect.origin.y + dy },
+      size: { ...orig.unrotatedRect.size }
+    };
+  }
+  return { dx, dy, rects };
+}
+function baseResizeScaling(orig, newRect, metadata) {
+  const oldRect = orig.unrotatedRect ?? orig.rect;
+  let scaleX = newRect.size.width / oldRect.size.width;
+  let scaleY = newRect.size.height / oldRect.size.height;
+  const minSize = 10;
+  if (newRect.size.width < minSize || newRect.size.height < minSize) {
+    scaleX = Math.max(scaleX, minSize / oldRect.size.width);
+    scaleY = Math.max(scaleY, minSize / oldRect.size.height);
+    newRect = {
+      origin: newRect.origin,
+      size: {
+        width: oldRect.size.width * scaleX,
+        height: oldRect.size.height * scaleY
+      }
+    };
+  }
+  if (metadata == null ? void 0 : metadata.maintainAspectRatio) {
+    const minScale = Math.min(scaleX, scaleY);
+    scaleX = minScale;
+    scaleY = minScale;
+    newRect = {
+      origin: newRect.origin,
+      size: {
+        width: oldRect.size.width * minScale,
+        height: oldRect.size.height * minScale
+      }
+    };
+  }
+  const rects = orig.unrotatedRect ? {
+    unrotatedRect: newRect,
+    rect: calculateRotatedRectAABB(newRect, orig.rotation ?? 0)
+  } : { rect: newRect };
+  return { scaleX, scaleY, oldRect, resolvedRect: newRect, rects };
+}
+function rotateOrbitDelta(orig, rotateResult) {
+  const baseRect = orig.unrotatedRect ?? orig.rect;
+  const newRect = rotateResult.unrotatedRect ?? baseRect;
+  return {
+    dx: newRect.origin.x - baseRect.origin.x,
+    dy: newRect.origin.y - baseRect.origin.y
+  };
+}
+function applyInsertUpright(annotation, pageRotation, rectWasDrawn) {
+  if (pageRotation === 0 || annotation.rotation !== void 0) return annotation;
+  const counterDeg = (4 - pageRotation) % 4 * 90;
+  let baseAnnotation = annotation;
+  if (rectWasDrawn && (pageRotation === 1 || pageRotation === 3)) {
+    const originalRect = annotation.rect;
+    const centerX = originalRect.origin.x + originalRect.size.width / 2;
+    const centerY = originalRect.origin.y + originalRect.size.height / 2;
+    baseAnnotation = {
+      ...annotation,
+      rect: {
+        origin: {
+          x: centerX - originalRect.size.height / 2,
+          y: centerY - originalRect.size.width / 2
+        },
+        size: {
+          width: originalRect.size.height,
+          height: originalRect.size.width
+        }
+      }
+    };
+  }
+  const { rotation, rect, unrotatedRect } = basePropertyRotationChanges(baseAnnotation, counterDeg);
+  return { ...baseAnnotation, rotation, rect, unrotatedRect };
+}
+function clampAnnotationToPage(annotation, pageSize) {
+  const clampedX = clamp(annotation.rect.origin.x, 0, pageSize.width - annotation.rect.size.width);
+  const clampedY = clamp(
+    annotation.rect.origin.y,
+    0,
+    pageSize.height - annotation.rect.size.height
+  );
+  const shiftX = clampedX - annotation.rect.origin.x;
+  const shiftY = clampedY - annotation.rect.origin.y;
+  if (shiftX === 0 && shiftY === 0) return annotation;
+  return {
+    ...annotation,
+    rect: { origin: { x: clampedX, y: clampedY }, size: annotation.rect.size },
+    ...annotation.unrotatedRect ? {
+      unrotatedRect: {
+        origin: {
+          x: annotation.unrotatedRect.origin.x + shiftX,
+          y: annotation.unrotatedRect.origin.y + shiftY
+        },
+        size: annotation.unrotatedRect.size
+      }
+    } : {}
+  };
+}
 const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   LINE_ENDING_HANDLERS,
   PatchRegistry,
+  applyInsertUpright,
+  calculateAABBFromVertices,
+  calculateRotatedRectAABB,
+  calculateRotatedRectAABBAroundPoint,
+  clampAnnotationToPage,
+  compensateRotatedVertexEdit,
   createEnding,
+  getRectCenter,
   lineRectWithEndings,
-  patchRegistry
+  patchRegistry,
+  resolveAnnotationRotationCenter,
+  resolveRotateRects,
+  resolveVertexEditRects,
+  rotatePointAroundCenter: rotatePointAround,
+  rotateVertices
 }, Symbol.toStringTag, { value: "Module" }));
+const freeTextHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.FREETEXT,
+  create(context) {
+    const { onCommit, onPreview, getTool, pageSize, pageIndex, pageRotation } = context;
+    const [getStart, setStart] = useState(null);
+    const clampToPage = (pos) => ({
+      x: clamp(pos.x, 0, pageSize.width),
+      y: clamp(pos.y, 0, pageSize.height)
+    });
+    const getDefaults = () => {
+      const tool = getTool();
+      if (!tool) return null;
+      return {
+        ...tool.defaults,
+        fontColor: tool.defaults.fontColor ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1,
+        fontSize: tool.defaults.fontSize ?? 12,
+        fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
+        color: tool.defaults.color ?? tool.defaults.backgroundColor ?? "transparent",
+        textAlign: tool.defaults.textAlign ?? PdfTextAlignment.Left,
+        verticalAlign: tool.defaults.verticalAlign ?? PdfVerticalAlignment.Top,
+        contents: tool.defaults.contents ?? "Insert text here",
+        flags: tool.defaults.flags ?? ["print"]
+      };
+    };
+    const clickDetector = useClickDetector({
+      threshold: 5,
+      getTool,
+      onClickDetected: (pos, tool) => {
+        var _a;
+        const defaults = getDefaults();
+        if (!defaults) return;
+        const clickConfig = tool.clickBehavior;
+        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
+        const { width, height } = clickConfig.defaultSize;
+        const rect = {
+          origin: { x: pos.x - width / 2, y: pos.y - height / 2 },
+          size: { width, height }
+        };
+        const contents = clickConfig.defaultContent ?? defaults.contents;
+        let anno = {
+          ...defaults,
+          contents,
+          type: PdfAnnotationSubtype.FREETEXT,
+          rect,
+          pageIndex,
+          id: uuidV4(),
+          created: /* @__PURE__ */ new Date()
+        };
+        if ((_a = tool.behavior) == null ? void 0 : _a.insertUpright) {
+          anno = applyInsertUpright(anno, pageRotation, false);
+        }
+        anno = clampAnnotationToPage(anno, pageSize);
+        onCommit(anno);
+      }
+    });
+    const getPreview = (current) => {
+      const start = getStart();
+      if (!start) return null;
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const minX = Math.min(start.x, current.x);
+      const minY = Math.min(start.y, current.y);
+      const width = Math.abs(start.x - current.x);
+      const height = Math.abs(start.y - current.y);
+      const rect = {
+        origin: { x: minX, y: minY },
+        size: { width, height }
+      };
+      return {
+        type: PdfAnnotationSubtype.FREETEXT,
+        bounds: rect,
+        data: {
+          ...defaults,
+          rect
+        }
+      };
+    };
+    return {
+      onPointerDown: (pos, evt) => {
+        var _a;
+        const clampedPos = clampToPage(pos);
+        setStart(clampedPos);
+        clickDetector.onStart(clampedPos);
+        onPreview(getPreview(clampedPos));
+        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
+      },
+      onPointerMove: (pos) => {
+        const clampedPos = clampToPage(pos);
+        clickDetector.onMove(clampedPos);
+        if (getStart() && clickDetector.hasMoved()) {
+          onPreview(getPreview(clampedPos));
+        }
+      },
+      onPointerUp: (pos, evt) => {
+        var _a, _b;
+        const start = getStart();
+        if (!start) return;
+        const defaults = getDefaults();
+        if (!defaults) return;
+        const clampedPos = clampToPage(pos);
+        if (!clickDetector.hasMoved()) {
+          clickDetector.onEnd(clampedPos);
+        } else {
+          const minX = Math.min(start.x, clampedPos.x);
+          const minY = Math.min(start.y, clampedPos.y);
+          const width = Math.abs(start.x - clampedPos.x);
+          const height = Math.abs(start.y - clampedPos.y);
+          const rect = {
+            origin: { x: minX, y: minY },
+            size: { width, height }
+          };
+          const tool = getTool();
+          let anno = {
+            ...defaults,
+            type: PdfAnnotationSubtype.FREETEXT,
+            rect,
+            pageIndex: context.pageIndex,
+            id: uuidV4(),
+            created: /* @__PURE__ */ new Date()
+          };
+          if ((_a = tool == null ? void 0 : tool.behavior) == null ? void 0 : _a.insertUpright) {
+            anno = applyInsertUpright(anno, pageRotation, true);
+          }
+          onCommit(anno);
+        }
+        setStart(null);
+        onPreview(null);
+        clickDetector.reset();
+        (_b = evt.releasePointerCapture) == null ? void 0 : _b.call(evt);
+      },
+      onPointerLeave: (_, evt) => {
+        var _a;
+        setStart(null);
+        onPreview(null);
+        clickDetector.reset();
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+      },
+      onPointerCancel: (_, evt) => {
+        var _a;
+        setStart(null);
+        onPreview(null);
+        clickDetector.reset();
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+      }
+    };
+  }
+};
 const lineHandlerFactory = {
   annotationType: PdfAnnotationSubtype.LINE,
   create(context) {
@@ -1953,22 +2219,19 @@ const squareHandlerFactory = {
 const stampHandlerFactory = {
   annotationType: PdfAnnotationSubtype.STAMP,
   create(context) {
-    const { services, onCommit, getTool, pageSize } = context;
+    const { services, onCommit, getTool, pageSize, pageRotation } = context;
     return {
       onPointerDown: (pos) => {
         const tool = getTool();
         if (!tool) return;
         const { imageSrc, imageSize } = tool.defaults;
         const placeStamp = (imageData, width, height) => {
-          const originX = pos.x - width / 2;
-          const originY = pos.y - height / 2;
-          const finalX = clamp(originX, 0, pageSize.width - width);
-          const finalY = clamp(originY, 0, pageSize.height - height);
+          var _a;
           const rect = {
-            origin: { x: finalX, y: finalY },
+            origin: { x: pos.x - width / 2, y: pos.y - height / 2 },
             size: { width, height }
           };
-          const anno = {
+          let anno = {
             ...tool.defaults,
             rect,
             type: PdfAnnotationSubtype.STAMP,
@@ -1979,6 +2242,10 @@ const stampHandlerFactory = {
             id: uuidV4(),
             created: /* @__PURE__ */ new Date()
           };
+          if ((_a = tool.behavior) == null ? void 0 : _a.insertUpright) {
+            anno = applyInsertUpright(anno, pageRotation, false);
+          }
+          anno = clampAnnotationToPage(anno, pageSize);
           onCommit(anno, { imageData });
         };
         if (imageSrc) {
@@ -2149,322 +2416,424 @@ const circleHandlerFactory = {
       }
     };
   }
-};
-const patchInk = (original, ctx) => {
-  var _a;
-  switch (ctx.type) {
-    case "vertex-edit":
-      return ctx.changes;
-    case "move":
-      if (ctx.changes.rect) {
-        const dx = ctx.changes.rect.origin.x - original.rect.origin.x;
-        const dy = ctx.changes.rect.origin.y - original.rect.origin.y;
-        const movedInkList = original.inkList.map((stroke) => ({
-          points: stroke.points.map((p) => ({
-            x: p.x + dx,
-            y: p.y + dy
-          }))
-        }));
-        return {
-          rect: ctx.changes.rect,
-          inkList: movedInkList
-        };
-      }
+};
+const patchInk = (original, ctx) => {
+  switch (ctx.type) {
+    case "vertex-edit":
       return ctx.changes;
-    case "resize":
-      if (ctx.changes.rect) {
-        const oldRect = original.rect;
-        const newRect = ctx.changes.rect;
-        let scaleX = newRect.size.width / oldRect.size.width;
-        let scaleY = newRect.size.height / oldRect.size.height;
-        const minSize = 10;
-        if (newRect.size.width < minSize || newRect.size.height < minSize) {
-          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
-          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
-          ctx.changes.rect = {
-            origin: newRect.origin,
-            size: {
-              width: oldRect.size.width * scaleX,
-              height: oldRect.size.height * scaleY
-            }
-          };
-        }
-        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
-          const minScale = Math.min(scaleX, scaleY);
-          scaleX = minScale;
-          scaleY = minScale;
-          ctx.changes.rect.size = {
-            width: oldRect.size.width * minScale,
-            height: oldRect.size.height * minScale
-          };
+    case "move": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { dx, dy, rects } = baseMoveChanges(original, ctx.changes.rect);
+      return {
+        ...rects,
+        inkList: original.inkList.map((stroke) => ({
+          points: stroke.points.map((p) => ({ x: p.x + dx, y: p.y + dy }))
+        }))
+      };
+    }
+    case "resize": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { 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 },
+        size: {
+          width: Math.max(1, r.size.width - pad * 2),
+          height: Math.max(1, r.size.height - pad * 2)
         }
-        const inset = (r, pad) => ({
-          origin: { x: r.origin.x + pad, y: r.origin.y + pad },
-          size: {
-            width: Math.max(1, r.size.width - pad * 2),
-            height: Math.max(1, r.size.height - pad * 2)
-          }
-        });
-        const strokeScale = Math.min(
-          ctx.changes.rect.size.width / oldRect.size.width,
-          ctx.changes.rect.size.height / oldRect.size.height
-        );
-        const newStrokeWidth = Math.max(1, Math.round(original.strokeWidth * strokeScale));
-        const innerOld = inset(oldRect, original.strokeWidth / 2);
-        const innerNew = inset(ctx.changes.rect, newStrokeWidth / 2);
-        const sx = innerNew.size.width / Math.max(innerOld.size.width, 1e-6);
-        const sy = innerNew.size.height / Math.max(innerOld.size.height, 1e-6);
-        const newInkList = original.inkList.map((stroke) => ({
+      });
+      const strokeScale = Math.min(
+        resolvedRect.size.width / oldRect.size.width,
+        resolvedRect.size.height / oldRect.size.height
+      );
+      const newStrokeWidth = Math.max(1, Math.round(original.strokeWidth * strokeScale));
+      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);
+      const sy = innerNew.size.height / Math.max(innerOld.size.height, 1e-6);
+      return {
+        ...rects,
+        inkList: original.inkList.map((stroke) => ({
           points: stroke.points.map((p) => ({
             x: innerNew.origin.x + (p.x - innerOld.origin.x) * sx,
             y: innerNew.origin.y + (p.y - innerOld.origin.y) * sy
           }))
-        }));
+        })),
+        strokeWidth: newStrokeWidth
+      };
+    }
+    case "rotate": {
+      const result = baseRotateChanges(original, ctx);
+      if (!result) return ctx.changes;
+      const { dx, dy } = rotateOrbitDelta(original, result);
+      return {
+        ...result,
+        inkList: original.inkList.map((stroke) => ({
+          points: stroke.points.map((p) => ({ x: p.x + dx, y: p.y + dy }))
+        }))
+      };
+    }
+    case "property-update": {
+      const needsRectUpdate = ctx.changes.strokeWidth !== void 0 || ctx.changes.rotation !== void 0;
+      if (!needsRectUpdate) return ctx.changes;
+      const merged = { ...original, ...ctx.changes };
+      const pts = merged.inkList.flatMap((s) => s.points);
+      const tightRect = expandRect(rectFromPoints(pts), merged.strokeWidth / 2);
+      const effectiveRotation = ctx.changes.rotation ?? original.rotation ?? 0;
+      if (original.unrotatedRect || ctx.changes.rotation !== void 0) {
         return {
-          rect: ctx.changes.rect,
-          inkList: newInkList,
-          strokeWidth: newStrokeWidth
+          ...ctx.changes,
+          unrotatedRect: tightRect,
+          rect: calculateRotatedRectAABBAroundPoint(
+            tightRect,
+            effectiveRotation,
+            resolveAnnotationRotationCenter(original)
+          )
         };
       }
-      return ctx.changes;
-    case "property-update":
-      if (ctx.changes.strokeWidth !== void 0) {
-        const merged = { ...original, ...ctx.changes };
-        const pts = merged.inkList.flatMap((s) => s.points);
-        const rect = expandRect(rectFromPoints(pts), merged.strokeWidth / 2);
-        return { ...ctx.changes, rect };
-      }
-      return ctx.changes;
+      return { ...ctx.changes, rect: tightRect };
+    }
     default:
       return ctx.changes;
   }
 };
 const patchLine = (orig, ctx) => {
-  var _a;
   switch (ctx.type) {
     case "vertex-edit":
       if (ctx.changes.linePoints) {
         const { start, end } = ctx.changes.linePoints;
-        const rect = lineRectWithEndings([start, end], orig.strokeWidth, orig.lineEndings);
-        return {
-          rect,
-          linePoints: { start, end }
-        };
-      }
-      return ctx.changes;
-    case "move":
-      if (ctx.changes.rect) {
-        const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
-        const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
+        const rawPoints = [start, end];
+        const rawRect = lineRectWithEndings(rawPoints, orig.strokeWidth, orig.lineEndings);
+        const compensated = compensateRotatedVertexEdit(orig, rawPoints, rawRect);
+        const rect = lineRectWithEndings(compensated, orig.strokeWidth, orig.lineEndings);
         return {
-          rect: ctx.changes.rect,
-          linePoints: {
-            start: { x: orig.linePoints.start.x + dx, y: orig.linePoints.start.y + dy },
-            end: { x: orig.linePoints.end.x + dx, y: orig.linePoints.end.y + dy }
-          }
+          ...resolveVertexEditRects(orig, rect),
+          linePoints: { start: compensated[0], end: compensated[1] }
         };
       }
       return ctx.changes;
-    case "resize":
-      if (ctx.changes.rect) {
-        const oldRect = orig.rect;
-        const newRect = ctx.changes.rect;
-        let scaleX = newRect.size.width / oldRect.size.width;
-        let scaleY = newRect.size.height / oldRect.size.height;
-        const minSize = 10;
-        if (newRect.size.width < minSize || newRect.size.height < minSize) {
-          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
-          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
-          ctx.changes.rect = {
-            origin: newRect.origin,
-            size: {
-              width: oldRect.size.width * scaleX,
-              height: oldRect.size.height * scaleY
-            }
-          };
-        }
-        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
-          const minScale = Math.min(scaleX, scaleY);
-          scaleX = minScale;
-          scaleY = minScale;
-          ctx.changes.rect.size = {
-            width: oldRect.size.width * minScale,
-            height: oldRect.size.height * minScale
-          };
+    case "move": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { dx, dy, rects } = baseMoveChanges(orig, ctx.changes.rect);
+      return {
+        ...rects,
+        linePoints: {
+          start: { x: orig.linePoints.start.x + dx, y: orig.linePoints.start.y + dy },
+          end: { x: orig.linePoints.end.x + dx, y: orig.linePoints.end.y + dy }
         }
-        const newLinePoints = {
+      };
+    }
+    case "resize": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { scaleX, scaleY, oldRect, resolvedRect, rects } = baseResizeScaling(
+        orig,
+        ctx.changes.rect,
+        ctx.metadata
+      );
+      return {
+        ...rects,
+        linePoints: {
           start: {
-            x: ctx.changes.rect.origin.x + (orig.linePoints.start.x - oldRect.origin.x) * scaleX,
-            y: ctx.changes.rect.origin.y + (orig.linePoints.start.y - oldRect.origin.y) * scaleY
+            x: resolvedRect.origin.x + (orig.linePoints.start.x - oldRect.origin.x) * scaleX,
+            y: resolvedRect.origin.y + (orig.linePoints.start.y - oldRect.origin.y) * scaleY
           },
           end: {
-            x: ctx.changes.rect.origin.x + (orig.linePoints.end.x - oldRect.origin.x) * scaleX,
-            y: ctx.changes.rect.origin.y + (orig.linePoints.end.y - oldRect.origin.y) * scaleY
+            x: resolvedRect.origin.x + (orig.linePoints.end.x - oldRect.origin.x) * scaleX,
+            y: resolvedRect.origin.y + (orig.linePoints.end.y - oldRect.origin.y) * scaleY
           }
-        };
+        }
+      };
+    }
+    case "rotate": {
+      const result = baseRotateChanges(orig, ctx);
+      if (!result) return ctx.changes;
+      const { dx, dy } = rotateOrbitDelta(orig, result);
+      return {
+        ...result,
+        linePoints: {
+          start: { x: orig.linePoints.start.x + dx, y: orig.linePoints.start.y + dy },
+          end: { x: orig.linePoints.end.x + dx, y: orig.linePoints.end.y + dy }
+        }
+      };
+    }
+    case "property-update": {
+      const needsRectUpdate = ctx.changes.strokeWidth !== void 0 || ctx.changes.lineEndings !== void 0 || ctx.changes.rotation !== void 0;
+      if (!needsRectUpdate) return ctx.changes;
+      const merged = { ...orig, ...ctx.changes };
+      const tightRect = lineRectWithEndings(
+        [merged.linePoints.start, merged.linePoints.end],
+        merged.strokeWidth,
+        merged.lineEndings
+      );
+      const effectiveRotation = ctx.changes.rotation ?? orig.rotation ?? 0;
+      if (orig.unrotatedRect || ctx.changes.rotation !== void 0) {
         return {
-          rect: ctx.changes.rect,
-          linePoints: newLinePoints
+          ...ctx.changes,
+          unrotatedRect: tightRect,
+          rect: calculateRotatedRectAABBAroundPoint(
+            tightRect,
+            effectiveRotation,
+            resolveAnnotationRotationCenter(orig)
+          )
         };
       }
-      return ctx.changes;
-    case "property-update":
-      if (ctx.changes.strokeWidth || ctx.changes.lineEndings) {
-        const merged = { ...orig, ...ctx.changes };
-        const rect = lineRectWithEndings(
-          [merged.linePoints.start, merged.linePoints.end],
-          merged.strokeWidth,
-          merged.lineEndings
-        );
-        return { ...ctx.changes, rect };
-      }
-      return ctx.changes;
+      return { ...ctx.changes, rect: tightRect };
+    }
     default:
       return ctx.changes;
   }
 };
 const patchPolyline = (orig, ctx) => {
-  var _a;
   switch (ctx.type) {
     case "vertex-edit":
       if (ctx.changes.vertices && ctx.changes.vertices.length) {
+        const rawVertices = ctx.changes.vertices;
+        const rawRect = lineRectWithEndings(rawVertices, orig.strokeWidth, orig.lineEndings);
+        const compensated = compensateRotatedVertexEdit(orig, rawVertices, rawRect);
+        const rect = lineRectWithEndings(compensated, orig.strokeWidth, orig.lineEndings);
         return {
-          rect: lineRectWithEndings(ctx.changes.vertices, orig.strokeWidth, orig.lineEndings),
-          vertices: ctx.changes.vertices
-        };
-      }
-      return ctx.changes;
-    case "move":
-      if (ctx.changes.rect) {
-        const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
-        const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
-        const moved = orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }));
-        return {
-          rect: ctx.changes.rect,
-          vertices: moved
+          ...resolveVertexEditRects(orig, rect),
+          vertices: compensated
         };
       }
       return ctx.changes;
-    case "resize":
-      if (ctx.changes.rect) {
-        const oldRect = orig.rect;
-        const newRect = ctx.changes.rect;
-        let scaleX = newRect.size.width / oldRect.size.width;
-        let scaleY = newRect.size.height / oldRect.size.height;
-        const minSize = 10;
-        if (newRect.size.width < minSize || newRect.size.height < minSize) {
-          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
-          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
-          ctx.changes.rect = {
-            origin: newRect.origin,
-            size: {
-              width: oldRect.size.width * scaleX,
-              height: oldRect.size.height * scaleY
-            }
-          };
-        }
-        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
-          const minScale = Math.min(scaleX, scaleY);
-          scaleX = minScale;
-          scaleY = minScale;
-          ctx.changes.rect.size = {
-            width: oldRect.size.width * minScale,
-            height: oldRect.size.height * minScale
-          };
-        }
-        const scaledVertices = orig.vertices.map((vertex) => ({
-          x: ctx.changes.rect.origin.x + (vertex.x - oldRect.origin.x) * scaleX,
-          y: ctx.changes.rect.origin.y + (vertex.y - oldRect.origin.y) * scaleY
-        }));
+    case "move": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { dx, dy, rects } = baseMoveChanges(orig, ctx.changes.rect);
+      return {
+        ...rects,
+        vertices: orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }))
+      };
+    }
+    case "resize": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { scaleX, scaleY, oldRect, resolvedRect, rects } = baseResizeScaling(
+        orig,
+        ctx.changes.rect,
+        ctx.metadata
+      );
+      return {
+        ...rects,
+        vertices: orig.vertices.map((v) => ({
+          x: resolvedRect.origin.x + (v.x - oldRect.origin.x) * scaleX,
+          y: resolvedRect.origin.y + (v.y - oldRect.origin.y) * scaleY
+        }))
+      };
+    }
+    case "rotate": {
+      const result = baseRotateChanges(orig, ctx);
+      if (!result) return ctx.changes;
+      const { dx, dy } = rotateOrbitDelta(orig, result);
+      return {
+        ...result,
+        vertices: orig.vertices.map((v) => ({ x: v.x + dx, y: v.y + dy }))
+      };
+    }
+    case "property-update": {
+      const needsRectUpdate = ctx.changes.strokeWidth !== void 0 || ctx.changes.lineEndings !== void 0 || ctx.changes.rotation !== void 0;
+      if (!needsRectUpdate) return ctx.changes;
+      const merged = { ...orig, ...ctx.changes };
+      const tightRect = lineRectWithEndings(
+        merged.vertices,
+        merged.strokeWidth,
+        merged.lineEndings
+      );
+      const effectiveRotation = ctx.changes.rotation ?? orig.rotation ?? 0;
+      if (orig.unrotatedRect || ctx.changes.rotation !== void 0) {
         return {
-          rect: ctx.changes.rect,
-          vertices: scaledVertices
+          ...ctx.changes,
+          unrotatedRect: tightRect,
+          rect: calculateRotatedRectAABBAroundPoint(
+            tightRect,
+            effectiveRotation,
+            resolveAnnotationRotationCenter(orig)
+          )
         };
       }
-      return ctx.changes;
-    case "property-update":
-      if (ctx.changes.strokeWidth !== void 0 || ctx.changes.lineEndings !== void 0) {
-        const merged = { ...orig, ...ctx.changes };
-        const rect = lineRectWithEndings(merged.vertices, merged.strokeWidth, merged.lineEndings);
-        return { ...ctx.changes, rect };
-      }
-      return ctx.changes;
+      return { ...ctx.changes, rect: tightRect };
+    }
     default:
       return ctx.changes;
   }
 };
 const patchPolygon = (orig, ctx) => {
-  var _a;
   switch (ctx.type) {
     case "vertex-edit":
       if (ctx.changes.vertices && ctx.changes.vertices.length) {
         const pad = orig.strokeWidth / 2;
+        const rawVertices = ctx.changes.vertices;
+        const rawRect = expandRect(rectFromPoints(rawVertices), pad);
+        const compensated = compensateRotatedVertexEdit(orig, rawVertices, rawRect);
+        const rect = expandRect(rectFromPoints(compensated), pad);
         return {
-          rect: expandRect(rectFromPoints(ctx.changes.vertices), pad),
-          vertices: ctx.changes.vertices
+          ...resolveVertexEditRects(orig, rect),
+          vertices: compensated
         };
       }
       return ctx.changes;
-    case "move":
-      if (ctx.changes.rect) {
-        const dx = ctx.changes.rect.origin.x - orig.rect.origin.x;
-        const dy = ctx.changes.rect.origin.y - orig.rect.origin.y;
-        const moved = orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }));
+    case "move": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { dx, dy, rects } = baseMoveChanges(orig, ctx.changes.rect);
+      return {
+        ...rects,
+        vertices: orig.vertices.map((p) => ({ x: p.x + dx, y: p.y + dy }))
+      };
+    }
+    case "resize": {
+      if (!ctx.changes.rect) return ctx.changes;
+      const { scaleX, scaleY, oldRect, resolvedRect, rects } = baseResizeScaling(
+        orig,
+        ctx.changes.rect,
+        ctx.metadata
+      );
+      return {
+        ...rects,
+        vertices: orig.vertices.map((v) => ({
+          x: resolvedRect.origin.x + (v.x - oldRect.origin.x) * scaleX,
+          y: resolvedRect.origin.y + (v.y - oldRect.origin.y) * scaleY
+        }))
+      };
+    }
+    case "rotate": {
+      const result = baseRotateChanges(orig, ctx);
+      if (!result) return ctx.changes;
+      const { dx, dy } = rotateOrbitDelta(orig, result);
+      return {
+        ...result,
+        vertices: orig.vertices.map((v) => ({ x: v.x + dx, y: v.y + dy }))
+      };
+    }
+    case "property-update": {
+      const needsRectUpdate = ctx.changes.strokeWidth !== void 0 || ctx.changes.rotation !== void 0;
+      if (!needsRectUpdate) return ctx.changes;
+      const merged = { ...orig, ...ctx.changes };
+      const pad = merged.strokeWidth / 2;
+      const tightRect = expandRect(rectFromPoints(merged.vertices), pad);
+      const effectiveRotation = ctx.changes.rotation ?? orig.rotation ?? 0;
+      if (orig.unrotatedRect || ctx.changes.rotation !== void 0) {
         return {
-          rect: ctx.changes.rect,
-          vertices: moved
+          ...ctx.changes,
+          unrotatedRect: tightRect,
+          rect: calculateRotatedRectAABBAroundPoint(
+            tightRect,
+            effectiveRotation,
+            resolveAnnotationRotationCenter(orig)
+          )
         };
       }
+      return { ...ctx.changes, rect: tightRect };
+    }
+    default:
       return ctx.changes;
+  }
+};
+const patchCircle = (orig, ctx) => {
+  switch (ctx.type) {
+    case "move":
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseMoveChanges(orig, ctx.changes.rect).rects;
     case "resize":
-      if (ctx.changes.rect) {
-        const oldRect = orig.rect;
-        const newRect = ctx.changes.rect;
-        let scaleX = newRect.size.width / oldRect.size.width;
-        let scaleY = newRect.size.height / oldRect.size.height;
-        const minSize = 10;
-        if (newRect.size.width < minSize || newRect.size.height < minSize) {
-          scaleX = Math.max(scaleX, minSize / oldRect.size.width);
-          scaleY = Math.max(scaleY, minSize / oldRect.size.height);
-          ctx.changes.rect = {
-            origin: newRect.origin,
-            size: {
-              width: oldRect.size.width * scaleX,
-              height: oldRect.size.height * scaleY
-            }
-          };
-        }
-        if ((_a = ctx.metadata) == null ? void 0 : _a.maintainAspectRatio) {
-          const minScale = Math.min(scaleX, scaleY);
-          scaleX = minScale;
-          scaleY = minScale;
-          ctx.changes.rect.size = {
-            width: oldRect.size.width * minScale,
-            height: oldRect.size.height * minScale
-          };
-        }
-        const scaledVertices = orig.vertices.map((vertex) => ({
-          x: ctx.changes.rect.origin.x + (vertex.x - oldRect.origin.x) * scaleX,
-          y: ctx.changes.rect.origin.y + (vertex.y - oldRect.origin.y) * scaleY
-        }));
-        return {
-          rect: ctx.changes.rect,
-          vertices: scaledVertices
-        };
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseResizeScaling(orig, ctx.changes.rect, ctx.metadata).rects;
+    case "rotate":
+      return baseRotateChanges(orig, ctx) ?? ctx.changes;
+    case "property-update":
+      if (ctx.changes.rotation !== void 0) {
+        return { ...ctx.changes, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
+      }
+      return ctx.changes;
+    default:
+      return ctx.changes;
+  }
+};
+const patchSquare = (orig, ctx) => {
+  switch (ctx.type) {
+    case "move":
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseMoveChanges(orig, ctx.changes.rect).rects;
+    case "resize":
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseResizeScaling(orig, ctx.changes.rect, ctx.metadata).rects;
+    case "rotate":
+      return baseRotateChanges(orig, ctx) ?? ctx.changes;
+    case "property-update":
+      if (ctx.changes.rotation !== void 0) {
+        return { ...ctx.changes, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
       }
       return ctx.changes;
+    default:
+      return ctx.changes;
+  }
+};
+const patchFreeText = (orig, ctx) => {
+  switch (ctx.type) {
+    case "move":
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseMoveChanges(orig, ctx.changes.rect).rects;
+    case "resize":
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseResizeScaling(orig, ctx.changes.rect, ctx.metadata).rects;
+    case "rotate":
+      return baseRotateChanges(orig, ctx) ?? ctx.changes;
+    case "property-update":
+      if (ctx.changes.rotation !== void 0) {
+        return { ...ctx.changes, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
+      }
+      return ctx.changes;
+    default:
+      return ctx.changes;
+  }
+};
+const patchStamp = (orig, ctx) => {
+  switch (ctx.type) {
+    case "move":
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseMoveChanges(orig, ctx.changes.rect).rects;
+    case "resize":
+      if (!ctx.changes.rect) return ctx.changes;
+      return baseResizeScaling(orig, ctx.changes.rect, ctx.metadata).rects;
+    case "rotate":
+      return baseRotateChanges(orig, ctx) ?? ctx.changes;
     case "property-update":
-      if (ctx.changes.strokeWidth !== void 0) {
-        const merged = { ...orig, ...ctx.changes };
-        const pad = merged.strokeWidth / 2;
-        const rect = expandRect(rectFromPoints(merged.vertices), pad);
-        return { ...ctx.changes, rect };
+      if (ctx.changes.rotation !== void 0) {
+        return { ...ctx.changes, ...basePropertyRotationChanges(orig, ctx.changes.rotation) };
       }
       return ctx.changes;
     default:
       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;
@@ -2484,6 +2853,8 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     this.unifiedDrag$ = createBehaviorEmitter();
     this.unifiedResizeStates = /* @__PURE__ */ new Map();
     this.unifiedResize$ = createBehaviorEmitter();
+    this.unifiedRotateStates = /* @__PURE__ */ new Map();
+    this.unifiedRotate$ = createBehaviorEmitter();
     this.config = config;
     this.selection = ((_a = registry.getPlugin("selection")) == null ? void 0 : _a.provides()) ?? null;
     this.history = ((_b = registry.getPlugin("history")) == null ? void 0 : _b.provides()) ?? null;
@@ -2513,7 +2884,11 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     if (this.selection) {
       for (const tool of this.state.tools) {
         if (tool.interaction.textSelection) {
-          this.selection.enableForMode(tool.interaction.mode ?? tool.id, { showRects: false });
+          this.selection.enableForMode(tool.interaction.mode ?? tool.id, {
+            showSelectionRects: false,
+            enableSelection: true,
+            enableMarquee: false
+          });
         }
       }
     }
@@ -2544,6 +2919,10 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     this.patchRegistry.register(PdfAnnotationSubtype.LINE, patchLine);
     this.patchRegistry.register(PdfAnnotationSubtype.POLYLINE, patchPolyline);
     this.patchRegistry.register(PdfAnnotationSubtype.POLYGON, patchPolygon);
+    this.patchRegistry.register(PdfAnnotationSubtype.CIRCLE, patchCircle);
+    this.patchRegistry.register(PdfAnnotationSubtype.SQUARE, patchSquare);
+    this.patchRegistry.register(PdfAnnotationSubtype.FREETEXT, patchFreeText);
+    this.patchRegistry.register(PdfAnnotationSubtype.STAMP, patchStamp);
   }
   async initialize() {
     var _a, _b, _c;
@@ -2563,7 +2942,8 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
         this.dispatch(setActiveToolId(s.documentId, newToolId));
       }
     });
-    (_b = this.selection) == null ? void 0 : _b.onMarqueeEnd(({ documentId, pageIndex, rect }) => {
+    (_b = this.selection) == null ? void 0 : _b.onMarqueeEnd(({ documentId, pageIndex, rect, modeId }) => {
+      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));
@@ -2595,6 +2975,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       if (!formattedSelection || !selectionText) return;
       for (const selection of formattedSelection) {
         selectionText.wait((text) => {
+          var _a3, _b3;
           const annotationId = uuidV4();
           this.createAnnotation(
             selection.pageIndex,
@@ -2612,10 +2993,10 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
             void 0,
             documentId
           );
-          if (this.getToolBehavior(activeTool, "deactivateToolAfterCreate")) {
+          if ((_a3 = activeTool.behavior) == null ? void 0 : _a3.deactivateToolAfterCreate) {
             this.setActiveTool(null, documentId);
           }
-          if (this.getToolBehavior(activeTool, "selectAfterCreate")) {
+          if ((_b3 = activeTool.behavior) == null ? void 0 : _b3.selectAfterCreate) {
             this.selectAnnotation(selection.pageIndex, annotationId, documentId);
           }
         }, ignore);
@@ -2752,6 +3133,9 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
             tool: this.getActiveTool(documentId)
           });
         }
+        if ((prevDoc == null ? void 0 : prevDoc.selectedUids) !== nextDoc.selectedUids) {
+          this.updateAnnotationSelectionActivity(documentId, nextDoc);
+        }
       }
     }
     if (prev.tools !== next.tools) {
@@ -2786,6 +3170,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     if (!this.interactionManager) return () => {
     };
     const unregisterFns = [];
+    const effectivePageRotation = ((page.rotation ?? 0) + ((docState == null ? void 0 : docState.rotation) ?? 0)) % 4;
     for (const tool of this.state.tools) {
       if (!tool.defaults.type) continue;
       const factory = this.handlerFactories.get(tool.defaults.type);
@@ -2793,16 +3178,18 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       const context = {
         pageIndex,
         pageSize: page.size,
+        pageRotation: effectivePageRotation,
         scale,
         services: callbacks.services,
         // Pass through services
         onPreview: (state) => callbacks.onPreview(tool.id, state),
         onCommit: (annotation, ctx) => {
+          var _a2, _b;
           this.createAnnotation(pageIndex, annotation, ctx, documentId);
-          if (this.getToolBehavior(tool, "deactivateToolAfterCreate")) {
+          if ((_a2 = tool.behavior) == null ? void 0 : _a2.deactivateToolAfterCreate) {
             this.setActiveTool(null, documentId);
           }
-          if (this.getToolBehavior(tool, "selectAfterCreate")) {
+          if ((_b = tool.behavior) == null ? void 0 : _b.selectAfterCreate) {
             this.selectAnnotation(pageIndex, annotation.id, documentId);
           }
         },
@@ -3125,6 +3512,27 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     const docId = documentId ?? this.getActiveDocumentId();
     this.dispatch(deselectAnnotation(docId));
   }
+  /**
+   * Derive page activity from the current annotation selection.
+   * Called from onStoreUpdated whenever selectedUids changes,
+   * so ALL selection code paths are covered automatically.
+   */
+  updateAnnotationSelectionActivity(docId, docState) {
+    var _a, _b;
+    if (docState.selectedUids.length === 0) {
+      (_a = this.interactionManager) == null ? void 0 : _a.releasePageActivity(docId, "annotation-selection");
+      return;
+    }
+    const firstUid = docState.selectedUids[0];
+    const ta = docState.byUid[firstUid];
+    if (ta) {
+      (_b = this.interactionManager) == null ? void 0 : _b.claimPageActivity(
+        docId,
+        "annotation-selection",
+        ta.object.pageIndex
+      );
+    }
+  }
   // ─────────────────────────────────────────────────────────
   // Multi-Select Methods
   // ─────────────────────────────────────────────────────────
@@ -3505,6 +3913,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     return annotations.map((anno) => ({
       id: anno.id,
       originalRect: anno.rect,
+      originalUnrotatedRect: anno.unrotatedRect,
       pageIndex: anno.pageIndex,
       isAttachedLink: anno.isAttachedLink,
       parentId: anno.parentId,
@@ -3541,12 +3950,24 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
    */
   computeResizePreviewPatches(computedRects, documentId) {
     const previewPatches = {};
+    const state = this.unifiedResizeStates.get(documentId);
+    const participantMap = state ? new Map(state.participatingAnnotations.map((p) => [p.id, p])) : void 0;
     for (const [id, newRect] of computedRects) {
       const ta = this.getAnnotationById(id, documentId);
       if (!ta) continue;
+      let targetRect = newRect;
+      const info = participantMap == null ? void 0 : participantMap.get(id);
+      if ((state == null ? void 0 : state.isGroupResize) && (info == null ? void 0 : info.originalUnrotatedRect)) {
+        targetRect = convertAABBRectToUnrotatedSpace(
+          newRect,
+          info.originalRect,
+          info.originalUnrotatedRect,
+          ta.object.rotation ?? 0
+        );
+      }
       previewPatches[id] = this.transformAnnotation(ta.object, {
         type: "resize",
-        changes: { rect: newRect }
+        changes: { rect: targetRect }
       });
     }
     return previewPatches;
@@ -3568,6 +3989,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
         annotationsWithLinks.push({
           id,
           rect: ta.object.rect,
+          unrotatedRect: ta.object.unrotatedRect ? this.cloneRect(ta.object.unrotatedRect) : void 0,
           pageIndex: ta.object.pageIndex,
           isAttachedLink: false
         });
@@ -3578,6 +4000,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
             annotationsWithLinks.push({
               id: link.object.id,
               rect: link.object.rect,
+              unrotatedRect: link.object.unrotatedRect ? this.cloneRect(link.object.unrotatedRect) : void 0,
               pageIndex: link.object.pageIndex,
               isAttachedLink: true,
               parentId: id
@@ -3597,6 +4020,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     const state = {
       documentId,
       isResizing: true,
+      isGroupResize: annotationIds.length > 1,
       primaryIds: annotationIds,
       attachedLinkIds,
       allParticipantIds,
@@ -3663,12 +4087,23 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       state.currentGroupBox
     );
     const patches = [];
+    const participantMap = new Map(state.participatingAnnotations.map((p) => [p.id, p]));
     for (const [id, newRect] of computedRects) {
       const ta = this.getAnnotationById(id, documentId);
       if (!ta) continue;
+      let targetRect = newRect;
+      const info = participantMap.get(id);
+      if (state.isGroupResize && (info == null ? void 0 : info.originalUnrotatedRect)) {
+        targetRect = convertAABBRectToUnrotatedSpace(
+          newRect,
+          info.originalRect,
+          info.originalUnrotatedRect,
+          ta.object.rotation ?? 0
+        );
+      }
       const patch = this.transformAnnotation(ta.object, {
         type: "resize",
-        changes: { rect: newRect }
+        changes: { rect: targetRect }
       });
       patches.push({ pageIndex: ta.object.pageIndex, id, patch });
     }
@@ -3719,6 +4154,206 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
   get onResizeChange() {
     return this.unifiedResize$.on;
   }
+  // ─────────────────────────────────────────────────────────
+  // Unified Rotation API (Plugin owns all rotation logic)
+  // ─────────────────────────────────────────────────────────
+  cloneRect(rect) {
+    return {
+      origin: { x: rect.origin.x, y: rect.origin.y },
+      size: { width: rect.size.width, height: rect.size.height }
+    };
+  }
+  translateRect(rect, delta) {
+    return {
+      origin: {
+        x: rect.origin.x + delta.x,
+        y: rect.origin.y + delta.y
+      },
+      size: { ...rect.size }
+    };
+  }
+  normalizeAngle(angle) {
+    const normalized = angle % 360;
+    return normalized < 0 ? normalized + 360 : normalized;
+  }
+  normalizeDelta(delta) {
+    const normalized = (delta + 540) % 360 - 180;
+    return normalized;
+  }
+  buildRotationParticipants(annotationIds, documentId) {
+    const participants = [];
+    const attachedLinkIds = [];
+    for (const id of annotationIds) {
+      const ta = this.getAnnotationById(id, documentId);
+      if (!ta) continue;
+      participants.push({
+        id,
+        rect: this.cloneRect(ta.object.rect),
+        pageIndex: ta.object.pageIndex,
+        rotation: ta.object.rotation ?? 0,
+        unrotatedRect: ta.object.unrotatedRect ? this.cloneRect(ta.object.unrotatedRect) : void 0,
+        isAttachedLink: false
+      });
+      const links = this.getAttachedLinksMethod(id, documentId);
+      for (const link of links) {
+        if (attachedLinkIds.includes(link.object.id)) continue;
+        attachedLinkIds.push(link.object.id);
+        participants.push({
+          id: link.object.id,
+          rect: this.cloneRect(link.object.rect),
+          pageIndex: link.object.pageIndex,
+          rotation: link.object.rotation ?? 0,
+          unrotatedRect: link.object.unrotatedRect ? this.cloneRect(link.object.unrotatedRect) : void 0,
+          isAttachedLink: true,
+          parentId: id
+        });
+      }
+    }
+    return { participants, attachedLinkIds };
+  }
+  computeRotatePreviewPatches(state, documentId) {
+    const preview = {};
+    for (const participant of state.participants) {
+      const ta = this.getAnnotationById(participant.id, documentId);
+      if (!ta) continue;
+      const originalCenter = resolveAnnotationRotationCenter({
+        rect: participant.rect,
+        unrotatedRect: participant.unrotatedRect,
+        rotation: participant.rotation
+      });
+      const rotatedCenter = rotatePointAround(
+        originalCenter,
+        state.rotationCenter,
+        state.delta
+      );
+      const translation = {
+        x: rotatedCenter.x - originalCenter.x,
+        y: rotatedCenter.y - originalCenter.y
+      };
+      const nextRotation = this.normalizeAngle(participant.rotation + state.delta);
+      const patch = this.transformAnnotation(ta.object, {
+        type: "rotate",
+        changes: {
+          rotation: nextRotation,
+          unrotatedRect: this.translateRect(
+            participant.unrotatedRect ?? participant.rect,
+            translation
+          )
+        },
+        metadata: {
+          rotationAngle: nextRotation,
+          rotationDelta: state.delta,
+          rotationCenter: state.rotationCenter
+        }
+      });
+      if (!patch.rect && (translation.x !== 0 || translation.y !== 0)) {
+        patch.rect = {
+          origin: {
+            x: ta.object.rect.origin.x + translation.x,
+            y: ta.object.rect.origin.y + translation.y
+          },
+          size: { ...ta.object.rect.size }
+        };
+      }
+      preview[participant.id] = patch;
+    }
+    return preview;
+  }
+  startRotation(documentId, options) {
+    const { annotationIds, cursorAngle, rotationCenter } = options;
+    const { participants, attachedLinkIds } = this.buildRotationParticipants(
+      annotationIds,
+      documentId
+    );
+    if (participants.length === 0) return;
+    const rects = participants.map((p) => p.rect);
+    const groupBox = this.computeUnifiedGroupBoundingBox(rects);
+    const center = rotationCenter ?? {
+      x: groupBox.origin.x + groupBox.size.width / 2,
+      y: groupBox.origin.y + groupBox.size.height / 2
+    };
+    const state = {
+      documentId,
+      isRotating: true,
+      primaryIds: annotationIds,
+      attachedLinkIds,
+      allParticipantIds: participants.map((p) => p.id),
+      rotationCenter: center,
+      cursorStartAngle: cursorAngle,
+      currentAngle: cursorAngle,
+      delta: 0,
+      participants
+    };
+    this.unifiedRotateStates.set(documentId, state);
+    const previewPatches = this.computeRotatePreviewPatches(state, documentId);
+    this.unifiedRotate$.emit({
+      documentId,
+      type: "start",
+      state,
+      previewPatches
+    });
+  }
+  updateRotation(documentId, cursorAngle, rotationDelta) {
+    const state = this.unifiedRotateStates.get(documentId);
+    if (!(state == null ? void 0 : state.isRotating)) {
+      return;
+    }
+    const delta = rotationDelta !== void 0 ? rotationDelta : this.normalizeDelta(cursorAngle - state.cursorStartAngle);
+    const newState = {
+      ...state,
+      currentAngle: cursorAngle,
+      delta
+    };
+    this.unifiedRotateStates.set(documentId, newState);
+    const previewPatches = this.computeRotatePreviewPatches(newState, documentId);
+    this.unifiedRotate$.emit({
+      documentId,
+      type: "update",
+      state: newState,
+      previewPatches
+    });
+  }
+  commitRotation(documentId) {
+    const state = this.unifiedRotateStates.get(documentId);
+    if (!state) return;
+    const previewPatches = this.computeRotatePreviewPatches(state, documentId);
+    const patches = [];
+    for (const [id, patch] of Object.entries(previewPatches)) {
+      const ta = this.getAnnotationById(id, documentId);
+      if (!ta) continue;
+      patches.push({ pageIndex: ta.object.pageIndex, id, patch });
+    }
+    if (patches.length > 0) {
+      this.updateAnnotationsMethod(patches, documentId);
+    }
+    this.unifiedRotate$.emit({
+      documentId,
+      type: "end",
+      state: { ...state, isRotating: false },
+      previewPatches
+    });
+    this.unifiedRotateStates.delete(documentId);
+  }
+  cancelRotation(documentId) {
+    const state = this.unifiedRotateStates.get(documentId);
+    if (!state) return;
+    this.unifiedRotate$.emit({
+      documentId,
+      type: "cancel",
+      state: { ...state, isRotating: false, delta: 0, currentAngle: state.cursorStartAngle },
+      previewPatches: {}
+    });
+    this.unifiedRotateStates.delete(documentId);
+  }
+  getRotateState(documentId) {
+    return this.unifiedRotateStates.get(documentId) ?? null;
+  }
+  /**
+   * Subscribe to unified rotation state changes.
+   */
+  get onRotateChange() {
+    return this.unifiedRotate$.on;
+  }
   updateAnnotationsMethod(patches, documentId) {
     const docId = documentId ?? this.getActiveDocumentId();
     if (!this.checkPermission(docId, PdfPermissionFlag.ModifyAnnotations)) {
@@ -4011,17 +4646,6 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     );
     return task;
   }
-  /**
-   * Gets the effective behavior setting for a tool, checking tool-specific config first,
-   * then falling back to plugin config.
-   */
-  getToolBehavior(tool, setting) {
-    var _a;
-    if (((_a = tool.behavior) == null ? void 0 : _a[setting]) !== void 0) {
-      return tool.behavior[setting];
-    }
-    return this.config[setting] !== false;
-  }
 };
 _AnnotationPlugin.id = "annotation";
 let AnnotationPlugin = _AnnotationPlugin;
@@ -4058,6 +4682,9 @@ export {
   ANNOTATION_PLUGIN_ID,
   AnnotationPlugin,
   AnnotationPluginPackage,
+  calculateRotatedRectAABB2 as calculateRotatedRectAABB,
+  calculateRotatedRectAABBAroundPoint2 as calculateRotatedRectAABBAroundPoint,
+  convertAABBRectToUnrotatedSpace,
   createToolPredicate,
   getAnnotationByUid,
   getAnnotations,
@@ -4067,6 +4694,7 @@ export {
   getGroupMembers,
   getIRTChildIds,
   getIRTChildrenByType,
+  getRectCenter2 as getRectCenter,
   getSelectedAnnotation,
   getSelectedAnnotationByPageIndex,
   getSelectedAnnotationIds,
@@ -4079,6 +4707,7 @@ export {
   hasAttachedLinks,
   hasIRTChildren,
   hasMultipleSelected,
+  inferRotationCenterFromRects2 as inferRotationCenterFromRects,
   initialDocumentState,
   initialState,
   isAnnotationSelected,
@@ -4116,6 +4745,8 @@ export {
   manifest,
   index as patching,
   rectsIntersect,
-  resolveInteractionProp
+  resolveInteractionProp,
+  rotatePointAround2 as rotatePointAroundCenter,
+  rotateVertices2 as rotateVertices
 };
 //# sourceMappingURL=index.js.map