@embedpdf/plugin-annotation 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { BasePlugin, createBehaviorEmitter, SET_DOCUMENT } from "@embedpdf/core";
-import { PdfAnnotationSubtype, PdfAnnotationLineEnding, rectFromPoints, expandRect, rotateAndTranslatePoint, PdfBlendMode, uuidV4, ignore, PdfTaskHelper, PdfErrorCode, Task, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, PdfAnnotationBorderStyle } from "@embedpdf/models";
+import { clamp, BasePlugin, createBehaviorEmitter, SET_DOCUMENT } from "@embedpdf/core";
+import { PdfAnnotationSubtype, expandRect, rectFromPoints, uuidV4, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, PdfAnnotationLineEnding, rotateAndTranslatePoint, PdfAnnotationBorderStyle, PdfAnnotationIcon, ignore, PdfTaskHelper, PdfErrorCode, Task, PdfBlendMode } from "@embedpdf/models";
 const ANNOTATION_PLUGIN_ID = "annotation";
 const manifest = {
   id: ANNOTATION_PLUGIN_ID,
@@ -11,20 +11,23 @@ const manifest = {
   defaultConfig: {
     enabled: true,
     autoCommit: true,
-    annotationAuthor: "Guest"
+    annotationAuthor: "Guest",
+    deactivateToolAfterCreate: false,
+    selectAfterCreate: true
   }
 };
 const SET_ANNOTATIONS = "ANNOTATION/SET_ANNOTATIONS";
 const SELECT_ANNOTATION = "ANNOTATION/SELECT_ANNOTATION";
 const DESELECT_ANNOTATION = "ANNOTATION/DESELECT_ANNOTATION";
-const UPDATE_TOOL_DEFAULTS = "ANNOTATION/UPDATE_TOOL_DEFAULTS";
 const ADD_COLOR_PRESET = "ANNOTATION/ADD_COLOR_PRESET";
 const CREATE_ANNOTATION = "ANNOTATION/CREATE_ANNOTATION";
 const PATCH_ANNOTATION = "ANNOTATION/PATCH_ANNOTATION";
 const DELETE_ANNOTATION = "ANNOTATION/DELETE_ANNOTATION";
 const COMMIT_PENDING_CHANGES = "ANNOTATION/COMMIT";
 const PURGE_ANNOTATION = "ANNOTATION/PURGE_ANNOTATION";
-const SET_ACTIVE_VARIANT = "ANNOTATION/SET_ACTIVE_VARIANT";
+const SET_ACTIVE_TOOL_ID = "ANNOTATION/SET_ACTIVE_TOOL_ID";
+const SET_TOOL_DEFAULTS = "ANNOTATION/SET_TOOL_DEFAULTS";
+const ADD_TOOL = "ANNOTATION/ADD_TOOL";
 const setAnnotations = (p) => ({
   type: SET_ANNOTATIONS,
   payload: p
@@ -34,19 +37,12 @@ const selectAnnotation = (pageIndex, id) => ({
   payload: { pageIndex, id }
 });
 const deselectAnnotation = () => ({ type: DESELECT_ANNOTATION });
-const updateToolDefaults = (variantKey, patch) => ({ type: UPDATE_TOOL_DEFAULTS, payload: { variantKey, patch } });
 const addColorPreset = (c) => ({
   type: ADD_COLOR_PRESET,
   payload: c
 });
-const createAnnotation = (pageIndex, annotation) => ({
-  type: CREATE_ANNOTATION,
-  payload: { pageIndex, annotation }
-});
-const patchAnnotation = (pageIndex, id, patch) => ({
-  type: PATCH_ANNOTATION,
-  payload: { pageIndex, id, patch }
-});
+const createAnnotation = (pageIndex, annotation) => ({ type: CREATE_ANNOTATION, payload: { pageIndex, annotation } });
+const patchAnnotation = (pageIndex, id, patch) => ({ type: PATCH_ANNOTATION, payload: { pageIndex, id, patch } });
 const deleteAnnotation = (pageIndex, id) => ({
   type: DELETE_ANNOTATION,
   payload: { pageIndex, id }
@@ -56,16 +52,15 @@ const purgeAnnotation = (uid) => ({
   type: PURGE_ANNOTATION,
   payload: { uid }
 });
-const setActiveVariant = (k) => ({
-  type: SET_ACTIVE_VARIANT,
-  payload: k
+const setActiveToolId = (id) => ({
+  type: SET_ACTIVE_TOOL_ID,
+  payload: id
 });
-const makeVariantKey = (subtype, intent) => intent ? `${subtype}#${intent}` : `${subtype}`;
-const parseVariantKey = (key) => {
-  const [subStr, intent] = key.split("#");
-  return { subtype: Number(subStr), intent };
-};
-const variantKeyFromAnnotation = (a) => makeVariantKey(a.type, a.intent);
+const setToolDefaults = (toolId, patch) => ({
+  type: SET_TOOL_DEFAULTS,
+  payload: { toolId, patch }
+});
+const addTool = (tool) => ({ type: ADD_TOOL, payload: tool });
 function isInk(a) {
   return a.object.type === PdfAnnotationSubtype.INK;
 }
@@ -111,21 +106,6 @@ function isText(a) {
 function isSidebarAnnotation(a) {
   return isTextMarkup(a) || isInk(a) || isSquare(a) || isCircle(a) || isPolygon(a) || isLine(a) || isPolyline(a) || isFreeText(a) || isStamp(a);
 }
-function isHighlightDefaults(defaults) {
-  return defaults.subtype === PdfAnnotationSubtype.HIGHLIGHT;
-}
-function isUnderlineDefaults(defaults) {
-  return defaults.subtype === PdfAnnotationSubtype.UNDERLINE;
-}
-function isStrikeoutDefaults(defaults) {
-  return defaults.subtype === PdfAnnotationSubtype.STRIKEOUT;
-}
-function isSquigglyDefaults(defaults) {
-  return defaults.subtype === PdfAnnotationSubtype.SQUIGGLY;
-}
-function isTextMarkupDefaults(defaults) {
-  return isHighlightDefaults(defaults) || isUnderlineDefaults(defaults) || isStrikeoutDefaults(defaults) || isSquigglyDefaults(defaults);
-}
 const getAnnotationsByPageIndex = (s, page) => (s.pages[page] ?? []).map((uid) => s.byUid[uid]);
 const getAnnotations = (s) => {
   const out = {};
@@ -141,26 +121,17 @@ const getSelectedAnnotationByPageIndex = (s, pageIndex) => {
   }
   return null;
 };
-const isInAnnotationVariant = (s) => s.activeVariant !== null;
-const getSelectedAnnotationVariant = (s) => s.activeVariant;
 const isAnnotationSelected = (s, id) => s.selectedUid === id;
-function getToolDefaultsBySubtypeAndIntent(state, subtype, intent) {
-  const variantKey = makeVariantKey(subtype, intent ?? void 0);
-  const fallbackKey = makeVariantKey(subtype);
-  const defaults = state.toolDefaults[variantKey] ?? state.toolDefaults[fallbackKey];
-  if (!defaults) {
-    throw new Error(
-      `No tool defaults found for subtype ${subtype}${intent ? ` and intent ${intent}` : ""}`
-    );
-  }
-  return defaults;
+function getToolDefaultsById(state, toolId) {
+  const tool = state.tools.find((t) => t.id === toolId);
+  return tool == null ? void 0 : tool.defaults;
 }
 const getSidebarAnnotationsWithRepliesGroupedByPage = (s) => {
   const repliesByParent = {};
   for (const uidList of Object.values(s.pages)) {
     for (const uid of uidList) {
       const ta = s.byUid[uid];
-      if (isText(ta)) {
+      if (ta && isText(ta)) {
         const parentId = ta.object.inReplyToId;
         if (parentId) (repliesByParent[parentId] || (repliesByParent[parentId] = [])).push(ta);
       }
@@ -172,7 +143,7 @@ const getSidebarAnnotationsWithRepliesGroupedByPage = (s) => {
     const pageAnnotations = [];
     for (const uid of uidList) {
       const ta = s.byUid[uid];
-      if (isSidebarAnnotation(ta)) {
+      if (ta && isSidebarAnnotation(ta)) {
         pageAnnotations.push({
           page,
           annotation: ta,
@@ -195,6 +166,293 @@ const getSidebarAnnotationsWithReplies = (s) => {
   }
   return out;
 };
+function useState(initialValue) {
+  let value = initialValue;
+  const getValue = () => value;
+  const setValue = (newValue) => {
+    value = newValue;
+  };
+  return [getValue, setValue];
+}
+const inkHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.INK,
+  create(context) {
+    const { onCommit, onPreview, getTool, pageSize } = context;
+    const [getStrokes, setStrokes] = useState([]);
+    const [getIsDrawing, setIsDrawing] = useState(false);
+    const timerRef = { current: 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,
+        strokeWidth: tool.defaults.strokeWidth ?? 1,
+        color: tool.defaults.color ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1
+      };
+    };
+    const getPreview = () => {
+      const strokes = getStrokes();
+      if (strokes.length === 0 || strokes[0].points.length === 0) return null;
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const allPoints = strokes.flatMap((s) => s.points);
+      const bounds = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
+      return {
+        type: PdfAnnotationSubtype.INK,
+        bounds,
+        data: {
+          ...defaults,
+          rect: bounds,
+          inkList: strokes
+        }
+      };
+    };
+    return {
+      onPointerDown: (pos, evt) => {
+        var _a;
+        const clampedPos = clampToPage(pos);
+        setIsDrawing(true);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        const newStrokes = [...getStrokes(), { points: [clampedPos] }];
+        setStrokes(newStrokes);
+        onPreview(getPreview());
+        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
+      },
+      onPointerMove: (pos) => {
+        if (!getIsDrawing()) return;
+        const strokes = getStrokes();
+        if (strokes.length === 0) return;
+        const clampedPos = clampToPage(pos);
+        strokes[strokes.length - 1].points.push(clampedPos);
+        setStrokes(strokes);
+        onPreview(getPreview());
+      },
+      onPointerUp: (_, evt) => {
+        var _a;
+        setIsDrawing(false);
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => {
+          const strokes = getStrokes();
+          if (strokes.length > 0 && strokes[0].points.length > 1) {
+            const defaults = getDefaults();
+            if (!defaults) return;
+            const allPoints = strokes.flatMap((s) => s.points);
+            const rect = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
+            onCommit({
+              ...defaults,
+              inkList: strokes,
+              rect,
+              type: PdfAnnotationSubtype.INK,
+              flags: ["print"],
+              pageIndex: context.pageIndex,
+              id: uuidV4(),
+              created: /* @__PURE__ */ new Date()
+            });
+          }
+          setStrokes([]);
+          onPreview(null);
+        }, 800);
+      },
+      onPointerCancel: (_, evt) => {
+        var _a;
+        setStrokes([]);
+        setIsDrawing(false);
+        onPreview(null);
+        if (timerRef.current) clearTimeout(timerRef.current);
+        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
+      }
+    };
+  }
+};
+function useClickDetector({
+  threshold = 5,
+  getTool,
+  onClickDetected
+}) {
+  const [getStartPos, setStartPos] = useState(null);
+  const [getHasMoved, setHasMoved] = useState(false);
+  return {
+    onStart: (pos) => {
+      setStartPos(pos);
+      setHasMoved(false);
+    },
+    onMove: (pos) => {
+      const start = getStartPos();
+      if (!start || getHasMoved()) return;
+      const distance = Math.sqrt(Math.pow(pos.x - start.x, 2) + Math.pow(pos.y - start.y, 2));
+      if (distance > threshold) {
+        setHasMoved(true);
+      }
+    },
+    onEnd: (pos) => {
+      var _a;
+      const start = getStartPos();
+      if (start && !getHasMoved()) {
+        const tool = getTool();
+        if (tool && "clickBehavior" in tool && ((_a = tool.clickBehavior) == null ? void 0 : _a.enabled)) {
+          onClickDetected(pos, tool);
+        }
+      }
+      setStartPos(null);
+      setHasMoved(false);
+    },
+    hasMoved: getHasMoved,
+    reset: () => {
+      setStartPos(null);
+      setHasMoved(false);
+    }
+  };
+}
+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,
+        backgroundColor: tool.defaults.backgroundColor ?? "transparent",
+        textAlign: tool.defaults.textAlign ?? PdfTextAlignment.Left,
+        verticalAlign: tool.defaults.verticalAlign ?? PdfVerticalAlignment.Top,
+        contents: tool.defaults.contents ?? "Insert text here"
+      };
+    };
+    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,
+          flags: ["print"],
+          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,
+            flags: ["print"],
+            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;
@@ -344,38 +602,6 @@ function lineRectWithEndings(vertices, strokeWidth, endings) {
   const pad = strokeWidth / 2 + EXTRA_PADDING * strokeWidth;
   return expandRect(baseRect, pad);
 }
-const vertsRect = (verts, sw) => expandRect(rectFromPoints(verts), sw / 2);
-function deriveRect(a) {
-  switch (a.type) {
-    /* mark‑ups already carry their real rect */
-    case PdfAnnotationSubtype.HIGHLIGHT:
-    case PdfAnnotationSubtype.UNDERLINE:
-    case PdfAnnotationSubtype.STRIKEOUT:
-    case PdfAnnotationSubtype.SQUIGGLY:
-    case PdfAnnotationSubtype.SQUARE:
-    case PdfAnnotationSubtype.CIRCLE:
-      return a.rect;
-    /* ink */
-    case PdfAnnotationSubtype.INK: {
-      const pts = a.inkList.flatMap((s) => s.points);
-      return vertsRect(pts, a.strokeWidth);
-    }
-    /* one‑segment */
-    case PdfAnnotationSubtype.LINE:
-      return lineRectWithEndings(
-        [a.linePoints.start, a.linePoints.end],
-        a.strokeWidth,
-        a.lineEndings
-      );
-    /* multi‑segment */
-    case PdfAnnotationSubtype.POLYLINE:
-      return lineRectWithEndings(a.vertices, a.strokeWidth, a.lineEndings);
-    case PdfAnnotationSubtype.POLYGON:
-      return vertsRect(a.vertices, a.strokeWidth);
-    default:
-      return a.rect;
-  }
-}
 function createEnding(ending, strokeWidth, rad, px, py) {
   if (!ending) return null;
   const handler = LINE_ENDING_HANDLERS[ending];
@@ -388,187 +614,1249 @@ function createEnding(ending, strokeWidth, rad, px, py) {
     filled: handler.filled
   };
 }
+class PatchRegistry {
+  constructor() {
+    this.patches = /* @__PURE__ */ new Map();
+  }
+  register(type, patchFn) {
+    this.patches.set(type, patchFn);
+  }
+  /**
+   * Transform an annotation based on the context.
+   * Returns the transformed properties or just the changes if no patch function exists.
+   */
+  transform(annotation, context) {
+    const patchFn = this.patches.get(annotation.type);
+    if (patchFn) {
+      return patchFn(annotation, context);
+    }
+    return context.changes;
+  }
+}
+const patchRegistry = new PatchRegistry();
 const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   LINE_ENDING_HANDLERS,
+  PatchRegistry,
   createEnding,
-  deriveRect,
-  lineRectWithEndings
+  lineRectWithEndings,
+  patchRegistry
 }, Symbol.toStringTag, { value: "Module" }));
+const lineHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.LINE,
+  create(context) {
+    const { pageIndex, onCommit, onPreview, getTool, pageSize } = 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,
+        strokeWidth: tool.defaults.strokeWidth ?? 1,
+        lineEndings: tool.defaults.lineEndings ?? {
+          start: PdfAnnotationLineEnding.None,
+          end: PdfAnnotationLineEnding.None
+        },
+        color: tool.defaults.color ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1,
+        strokeStyle: tool.defaults.strokeStyle ?? PdfAnnotationBorderStyle.SOLID,
+        strokeDashArray: tool.defaults.strokeDashArray ?? [],
+        strokeColor: tool.defaults.strokeColor ?? "#000000"
+      };
+    };
+    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 angle = clickConfig.defaultAngle ?? 0;
+        const length = clickConfig.defaultLength;
+        const halfLength = length / 2;
+        const startX = pos.x - halfLength * Math.cos(angle);
+        const startY = pos.y - halfLength * Math.sin(angle);
+        const endX = pos.x + halfLength * Math.cos(angle);
+        const endY = pos.y + halfLength * Math.sin(angle);
+        const start = clampToPage({ x: startX, y: startY });
+        const end = clampToPage({ x: endX, y: endY });
+        const rect = lineRectWithEndings(
+          [start, end],
+          defaults.strokeWidth,
+          defaults.lineEndings
+        );
+        onCommit({
+          ...defaults,
+          rect,
+          linePoints: { start, end },
+          pageIndex,
+          id: uuidV4(),
+          flags: ["print"],
+          created: /* @__PURE__ */ new Date(),
+          type: PdfAnnotationSubtype.LINE
+        });
+      }
+    });
+    const getPreview = (current) => {
+      const start = getStart();
+      if (!start) return null;
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const bounds = lineRectWithEndings(
+        [start, current],
+        defaults.strokeWidth,
+        defaults.lineEndings
+      );
+      return {
+        type: PdfAnnotationSubtype.LINE,
+        bounds,
+        data: {
+          ...defaults,
+          rect: bounds,
+          linePoints: { start, end: current }
+        }
+      };
+    };
+    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 clampedPos = clampToPage(pos);
+        if (!clickDetector.hasMoved()) {
+          clickDetector.onEnd(clampedPos);
+        } else {
+          const defaults = getDefaults();
+          if (!defaults) return;
+          if (Math.abs(clampedPos.x - start.x) > 2 || Math.abs(clampedPos.y - start.y) > 2) {
+            const rect = lineRectWithEndings(
+              [start, clampedPos],
+              defaults.strokeWidth,
+              defaults.lineEndings
+            );
+            onCommit({
+              ...defaults,
+              rect,
+              linePoints: { start, end: clampedPos },
+              pageIndex,
+              id: uuidV4(),
+              flags: ["print"],
+              created: /* @__PURE__ */ new Date(),
+              type: PdfAnnotationSubtype.LINE
+            });
+          }
+        }
+        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);
+      }
+    };
+  }
+};
+const polylineHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.POLYLINE,
+  create(context) {
+    const { onCommit, onPreview, getTool, pageSize } = context;
+    const [getVertices, setVertices] = useState([]);
+    const [getCurrent, setCurrent] = 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,
+        strokeWidth: tool.defaults.strokeWidth ?? 1,
+        lineEndings: tool.defaults.lineEndings ?? {
+          start: PdfAnnotationLineEnding.None,
+          end: PdfAnnotationLineEnding.None
+        },
+        color: tool.defaults.color ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1,
+        strokeColor: tool.defaults.strokeColor ?? "#000000",
+        strokeStyle: tool.defaults.strokeStyle ?? PdfAnnotationBorderStyle.SOLID,
+        strokeDashArray: tool.defaults.strokeDashArray ?? []
+      };
+    };
+    const commitPolyline = () => {
+      const vertices = getVertices();
+      if (vertices.length < 2) return;
+      const defaults = getDefaults();
+      if (!defaults) return;
+      const rect = lineRectWithEndings(
+        vertices,
+        defaults.strokeWidth,
+        defaults.lineEndings
+      );
+      const anno = {
+        ...defaults,
+        vertices,
+        rect,
+        type: PdfAnnotationSubtype.POLYLINE,
+        flags: ["print"],
+        pageIndex: context.pageIndex,
+        id: uuidV4(),
+        created: /* @__PURE__ */ new Date()
+      };
+      onCommit(anno);
+      setVertices([]);
+      setCurrent(null);
+      onPreview(null);
+    };
+    const getPreview = () => {
+      const vertices = getVertices();
+      const currentPos = getCurrent();
+      if (vertices.length === 0 || !currentPos) return null;
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const allPoints = [...vertices, currentPos];
+      const bounds = lineRectWithEndings(
+        allPoints,
+        defaults.strokeWidth,
+        defaults.lineEndings
+      );
+      return {
+        type: PdfAnnotationSubtype.POLYLINE,
+        bounds,
+        data: {
+          ...defaults,
+          rect: bounds,
+          vertices: allPoints,
+          currentVertex: currentPos
+        }
+      };
+    };
+    return {
+      onClick: (pos) => {
+        const clampedPos = clampToPage(pos);
+        const vertices = getVertices();
+        const lastVertex = vertices[vertices.length - 1];
+        if (lastVertex && Math.abs(lastVertex.x - clampedPos.x) < 1 && Math.abs(lastVertex.y - clampedPos.y) < 1) {
+          return;
+        }
+        setVertices([...vertices, clampedPos]);
+        setCurrent(clampedPos);
+        onPreview(getPreview());
+      },
+      onDoubleClick: () => {
+        commitPolyline();
+      },
+      onPointerMove: (pos) => {
+        if (getVertices().length > 0) {
+          const clampedPos = clampToPage(pos);
+          setCurrent(clampedPos);
+          onPreview(getPreview());
+        }
+      },
+      onPointerCancel: () => {
+        setVertices([]);
+        setCurrent(null);
+        onPreview(null);
+      }
+    };
+  }
+};
+const HANDLE_SIZE_PX = 14;
+const polygonHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.POLYGON,
+  create(context) {
+    const { onCommit, onPreview, getTool, scale, pageSize } = context;
+    const [getVertices, setVertices] = useState([]);
+    const [getCurrent, setCurrent] = useState(null);
+    const clampToPage = (pos) => ({
+      x: clamp(pos.x, 0, pageSize.width),
+      y: clamp(pos.y, 0, pageSize.height)
+    });
+    const isInsideStartHandle = (pos) => {
+      const vertices = getVertices();
+      if (vertices.length < 2) return false;
+      const sizePDF = HANDLE_SIZE_PX / scale;
+      const half = sizePDF / 2;
+      const v0 = vertices[0];
+      return pos.x >= v0.x - half && pos.x <= v0.x + half && pos.y >= v0.y - half && pos.y <= v0.y + half;
+    };
+    const getDefaults = () => {
+      const tool = getTool();
+      if (!tool) return null;
+      return {
+        ...tool.defaults,
+        color: tool.defaults.color ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1,
+        strokeWidth: tool.defaults.strokeWidth ?? 1,
+        strokeColor: tool.defaults.strokeColor ?? "#000000",
+        strokeStyle: tool.defaults.strokeStyle ?? PdfAnnotationBorderStyle.SOLID,
+        strokeDashArray: tool.defaults.strokeDashArray ?? []
+      };
+    };
+    const commitPolygon = () => {
+      const vertices = getVertices();
+      if (vertices.length < 3) return;
+      const defaults = getDefaults();
+      if (!defaults) return;
+      const rect = expandRect(rectFromPoints(vertices), defaults.strokeWidth / 2);
+      const anno = {
+        ...defaults,
+        vertices,
+        rect,
+        type: PdfAnnotationSubtype.POLYGON,
+        flags: ["print"],
+        pageIndex: context.pageIndex,
+        id: uuidV4(),
+        created: /* @__PURE__ */ new Date()
+      };
+      onCommit(anno);
+      setVertices([]);
+      setCurrent(null);
+      onPreview(null);
+    };
+    const getPreview = () => {
+      const vertices = getVertices();
+      const currentPos = getCurrent();
+      if (vertices.length === 0 || !currentPos) return null;
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const allPoints = [...vertices, currentPos];
+      const bounds = expandRect(rectFromPoints(allPoints), defaults.strokeWidth / 2);
+      return {
+        type: PdfAnnotationSubtype.POLYGON,
+        bounds,
+        data: {
+          ...defaults,
+          rect: bounds,
+          vertices,
+          currentVertex: currentPos
+        }
+      };
+    };
+    return {
+      onClick: (pos) => {
+        const clampedPos = clampToPage(pos);
+        if (isInsideStartHandle(clampedPos) && getVertices().length >= 3) {
+          commitPolygon();
+          return;
+        }
+        const vertices = getVertices();
+        const lastVertex = vertices[vertices.length - 1];
+        if (lastVertex && Math.abs(lastVertex.x - clampedPos.x) < 1 && Math.abs(lastVertex.y - clampedPos.y) < 1) {
+          return;
+        }
+        setVertices([...vertices, clampedPos]);
+        setCurrent(clampedPos);
+        onPreview(getPreview());
+      },
+      onDoubleClick: (_) => {
+        commitPolygon();
+      },
+      onPointerMove: (pos) => {
+        if (getVertices().length > 0) {
+          const clampedPos = clampToPage(pos);
+          setCurrent(clampedPos);
+          onPreview(getPreview());
+        }
+      },
+      onPointerCancel: (_) => {
+        setVertices([]);
+        setCurrent(null);
+        onPreview(null);
+      }
+    };
+  }
+};
+const squareHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.SQUARE,
+  create(context) {
+    const { pageIndex, onCommit, onPreview, getTool, pageSize } = 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,
+        strokeWidth: tool.defaults.strokeWidth ?? 2,
+        strokeColor: tool.defaults.strokeColor ?? "#000000",
+        strokeStyle: tool.defaults.strokeStyle ?? PdfAnnotationBorderStyle.SOLID,
+        strokeDashArray: tool.defaults.strokeDashArray ?? [],
+        color: tool.defaults.color ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1
+      };
+    };
+    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 strokeWidth = defaults.strokeWidth;
+        const halfStroke = strokeWidth / 2;
+        const rect = {
+          origin: { x: x - halfStroke, y: y - halfStroke },
+          size: { width: width + strokeWidth, height: height + strokeWidth }
+        };
+        const anno = {
+          ...defaults,
+          type: PdfAnnotationSubtype.SQUARE,
+          flags: ["print"],
+          created: /* @__PURE__ */ new Date(),
+          id: uuidV4(),
+          pageIndex,
+          rect
+        };
+        onCommit(anno);
+      }
+    });
+    const getPreview = (current) => {
+      const p1 = getStart();
+      if (!p1) return null;
+      const minX = Math.min(p1.x, current.x);
+      const minY = Math.min(p1.y, current.y);
+      const width = Math.abs(p1.x - current.x);
+      const height = Math.abs(p1.y - current.y);
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const strokeWidth = defaults.strokeWidth;
+      const halfStroke = strokeWidth / 2;
+      const rect = {
+        origin: { x: minX - halfStroke, y: minY - halfStroke },
+        size: { width: width + strokeWidth, height: height + strokeWidth }
+      };
+      return {
+        type: PdfAnnotationSubtype.SQUARE,
+        bounds: rect,
+        data: {
+          rect,
+          ...defaults
+        }
+      };
+    };
+    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 p1 = getStart();
+        if (!p1) return;
+        const defaults = getDefaults();
+        if (!defaults) return;
+        const clampedPos = clampToPage(pos);
+        if (!clickDetector.hasMoved()) {
+          clickDetector.onEnd(clampedPos);
+        } else {
+          const defaults2 = getDefaults();
+          if (!defaults2) return;
+          const preview = getPreview(clampedPos);
+          if (preview) {
+            const anno = {
+              ...defaults2,
+              type: PdfAnnotationSubtype.SQUARE,
+              flags: ["print"],
+              created: /* @__PURE__ */ new Date(),
+              id: uuidV4(),
+              pageIndex,
+              rect: preview.data.rect
+            };
+            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);
+      }
+    };
+  }
+};
+const stampHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.STAMP,
+  create(context) {
+    const { services, onCommit, getTool, pageSize } = 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);
+          const rect = {
+            origin: { x: finalX, y: finalY },
+            size: { width, height }
+          };
+          const anno = {
+            rect,
+            type: PdfAnnotationSubtype.STAMP,
+            icon: PdfAnnotationIcon.Draft,
+            subject: "Stamp",
+            pageIndex: context.pageIndex,
+            id: uuidV4(),
+            created: /* @__PURE__ */ new Date(),
+            flags: ["print"]
+          };
+          onCommit(anno, { imageData });
+        };
+        if (imageSrc) {
+          services.processImage({
+            source: imageSrc,
+            maxWidth: pageSize.width,
+            maxHeight: pageSize.height,
+            onComplete: (result) => placeStamp(
+              result.imageData,
+              (imageSize == null ? void 0 : imageSize.width) ?? result.width,
+              (imageSize == null ? void 0 : imageSize.height) ?? result.height
+            )
+          });
+        } else {
+          services.requestFile({
+            accept: "image/png,image/jpeg",
+            onFile: (file) => {
+              services.processImage({
+                source: file,
+                maxWidth: pageSize.width,
+                maxHeight: pageSize.height,
+                onComplete: (result) => placeStamp(result.imageData, result.width, result.height)
+              });
+            }
+          });
+        }
+      }
+    };
+  }
+};
+const circleHandlerFactory = {
+  annotationType: PdfAnnotationSubtype.CIRCLE,
+  create(context) {
+    const { pageIndex, onCommit, onPreview, getTool, pageSize } = 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,
+        strokeWidth: tool.defaults.strokeWidth ?? 2,
+        strokeColor: tool.defaults.strokeColor ?? "#000000",
+        strokeStyle: tool.defaults.strokeStyle ?? PdfAnnotationBorderStyle.SOLID,
+        strokeDashArray: tool.defaults.strokeDashArray ?? [],
+        color: tool.defaults.color ?? "#000000",
+        opacity: tool.defaults.opacity ?? 1
+      };
+    };
+    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 strokeWidth = defaults.strokeWidth;
+        const halfStroke = strokeWidth / 2;
+        const rect = {
+          origin: { x: x - halfStroke, y: y - halfStroke },
+          size: { width: width + strokeWidth, height: height + strokeWidth }
+        };
+        const anno = {
+          ...defaults,
+          type: PdfAnnotationSubtype.CIRCLE,
+          flags: ["print"],
+          created: /* @__PURE__ */ new Date(),
+          id: uuidV4(),
+          pageIndex,
+          rect
+        };
+        onCommit(anno);
+      }
+    });
+    const getPreview = (current) => {
+      const p1 = getStart();
+      if (!p1) return null;
+      const minX = Math.min(p1.x, current.x);
+      const minY = Math.min(p1.y, current.y);
+      const width = Math.abs(p1.x - current.x);
+      const height = Math.abs(p1.y - current.y);
+      const defaults = getDefaults();
+      if (!defaults) return null;
+      const strokeWidth = defaults.strokeWidth;
+      const halfStroke = strokeWidth / 2;
+      const rect = {
+        origin: { x: minX - halfStroke, y: minY - halfStroke },
+        size: { width: width + strokeWidth, height: height + strokeWidth }
+      };
+      return {
+        type: PdfAnnotationSubtype.CIRCLE,
+        bounds: rect,
+        data: {
+          rect,
+          ...defaults
+        }
+      };
+    };
+    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 p1 = getStart();
+        if (!p1) return;
+        const defaults = getDefaults();
+        if (!defaults) return;
+        const clampedPos = clampToPage(pos);
+        if (!clickDetector.hasMoved()) {
+          clickDetector.onEnd(clampedPos);
+        } else {
+          const defaults2 = getDefaults();
+          if (!defaults2) return;
+          const preview = getPreview(clampedPos);
+          if (preview) {
+            const anno = {
+              ...defaults2,
+              type: PdfAnnotationSubtype.CIRCLE,
+              flags: ["print"],
+              created: /* @__PURE__ */ new Date(),
+              id: uuidV4(),
+              pageIndex,
+              rect: preview.data.rect
+            };
+            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);
+      }
+    };
+  }
+};
+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
+        };
+      }
+      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
+          };
+        }
+        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) => ({
+          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
+          }))
+        }));
+        return {
+          rect: ctx.changes.rect,
+          inkList: newInkList,
+          strokeWidth: newStrokeWidth
+        };
+      }
+      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;
+    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;
+        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 }
+          }
+        };
+      }
+      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 newLinePoints = {
+          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
+          },
+          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
+          }
+        };
+        return {
+          rect: ctx.changes.rect,
+          linePoints: newLinePoints
+        };
+      }
+      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;
+    default:
+      return ctx.changes;
+  }
+};
+const patchPolyline = (orig, ctx) => {
+  var _a;
+  switch (ctx.type) {
+    case "vertex-edit":
+      if (ctx.changes.vertices && ctx.changes.vertices.length) {
+        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
+        };
+      }
+      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
+        }));
+        return {
+          rect: ctx.changes.rect,
+          vertices: scaledVertices
+        };
+      }
+      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;
+    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;
+        return {
+          rect: expandRect(rectFromPoints(ctx.changes.vertices), pad),
+          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
+        };
+      }
+      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
+        }));
+        return {
+          rect: ctx.changes.rect,
+          vertices: scaledVertices
+        };
+      }
+      return 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 };
+      }
+      return ctx.changes;
+    default:
+      return ctx.changes;
+  }
+};
 const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
   constructor(id, registry, config) {
+    var _a, _b, _c;
     super(id, registry);
     this.ANNOTATION_HISTORY_TOPIC = "annotations";
     this.state$ = createBehaviorEmitter();
-    this.modeByVariant = /* @__PURE__ */ new Map();
-    this.variantByMode = /* @__PURE__ */ new Map();
     this.pendingContexts = /* @__PURE__ */ new Map();
-    this.activeVariantChange$ = createBehaviorEmitter();
-    this.activeTool$ = createBehaviorEmitter({
-      variantKey: null,
-      defaults: null
-    });
+    this.handlerFactories = /* @__PURE__ */ new Map();
+    this.activeTool$ = createBehaviorEmitter(null);
+    this.events$ = createBehaviorEmitter();
+    this.patchRegistry = new PatchRegistry();
+    this.isInitialLoadComplete = false;
+    this.importQueue = [];
     this.config = config;
-    const selection = registry.getPlugin("selection");
-    this.selection = (selection == null ? void 0 : selection.provides()) ?? null;
-    const history = registry.getPlugin("history");
-    this.history = (history == null ? void 0 : history.provides()) ?? null;
-    const interactionManager = registry.getPlugin("interaction-manager");
-    this.interactionManager = (interactionManager == null ? void 0 : interactionManager.provides()) ?? null;
-    this.coreStore.onAction(SET_DOCUMENT, (_action, state) => {
+    this.selection = ((_a = registry.getPlugin("selection")) == null ? void 0 : _a.provides()) ?? null;
+    this.history = ((_b = registry.getPlugin("history")) == null ? void 0 : _b.provides()) ?? null;
+    this.interactionManager = ((_c = registry.getPlugin("interaction-manager")) == null ? void 0 : _c.provides()) ?? null;
+    this.coreStore.onAction(SET_DOCUMENT, (_, state) => {
       const doc = state.core.document;
-      if (doc) {
-        this.getAllAnnotations(doc);
-      }
+      this.isInitialLoadComplete = false;
+      if (doc) this.getAllAnnotations(doc);
     });
+    this.registerHandlerFactories();
+    this.registerBuiltInPatches();
+  }
+  registerHandlerFactories() {
+    this.handlerFactories.set(PdfAnnotationSubtype.CIRCLE, circleHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.SQUARE, squareHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.STAMP, stampHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.POLYGON, polygonHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.POLYLINE, polylineHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.LINE, lineHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.INK, inkHandlerFactory);
+    this.handlerFactories.set(PdfAnnotationSubtype.FREETEXT, freeTextHandlerFactory);
+  }
+  registerBuiltInPatches() {
+    this.patchRegistry.register(PdfAnnotationSubtype.INK, patchInk);
+    this.patchRegistry.register(PdfAnnotationSubtype.LINE, patchLine);
+    this.patchRegistry.register(PdfAnnotationSubtype.POLYLINE, patchPolyline);
+    this.patchRegistry.register(PdfAnnotationSubtype.POLYGON, patchPolygon);
   }
   async initialize() {
     var _a, _b, _c;
-    for (const [variantKey, defaults] of Object.entries(this.state.toolDefaults)) {
-      this.registerTool(variantKey, defaults);
-    }
+    this.state.tools.forEach((tool) => this.registerInteractionForTool(tool));
     (_a = this.history) == null ? void 0 : _a.onHistoryChange((topic) => {
       if (topic === this.ANNOTATION_HISTORY_TOPIC && this.config.autoCommit !== false) {
         this.commit();
       }
     });
     (_b = this.interactionManager) == null ? void 0 : _b.onModeChange((s) => {
-      const newVariant = this.variantByMode.get(s.activeMode) ?? null;
-      if (newVariant !== this.state.activeVariant) {
-        this.dispatch(setActiveVariant(newVariant));
-        this.activeVariantChange$.emit(newVariant);
+      var _a2;
+      const newToolId = ((_a2 = this.state.tools.find((t) => t.interaction.mode === s.activeMode)) == null ? void 0 : _a2.id) ?? null;
+      if (newToolId !== this.state.activeToolId) {
+        this.dispatch(setActiveToolId(newToolId));
       }
     });
     (_c = this.selection) == null ? void 0 : _c.onEndSelection(() => {
       var _a2, _b2, _c2;
-      if (!this.state.activeVariant) return;
-      const defaults = this.state.toolDefaults[this.state.activeVariant];
-      if (!defaults || !isTextMarkupDefaults(defaults)) return;
+      const activeTool = this.getActiveTool();
+      if (!activeTool || !activeTool.interaction.textSelection) return;
       const formattedSelection = (_a2 = this.selection) == null ? void 0 : _a2.getFormattedSelection();
       const selectionText = (_b2 = this.selection) == null ? void 0 : _b2.getSelectedText();
       if (!formattedSelection || !selectionText) return;
       for (const selection of formattedSelection) {
-        const rect = selection.rect;
-        const segmentRects = selection.segmentRects;
-        const subtype = defaults.subtype;
-        const color = defaults.color;
-        const opacity = defaults.opacity;
-        const blendMode = defaults.blendMode ?? PdfBlendMode.Normal;
         selectionText.wait((text) => {
+          const annotationId = uuidV4();
           this.createAnnotation(selection.pageIndex, {
-            type: subtype,
-            rect,
-            segmentRects,
-            color,
-            opacity,
-            flags: ["print"],
-            blendMode,
+            ...activeTool.defaults,
+            rect: selection.rect,
+            segmentRects: selection.segmentRects,
             pageIndex: selection.pageIndex,
-            id: uuidV4(),
-            author: this.config.annotationAuthor,
+            created: /* @__PURE__ */ new Date(),
+            id: annotationId,
             custom: {
               text: text.join("\n")
             }
           });
+          if (this.getToolBehavior(activeTool, "deactivateToolAfterCreate")) {
+            this.setActiveTool(null);
+          }
+          if (this.getToolBehavior(activeTool, "selectAfterCreate")) {
+            this.selectAnnotation(selection.pageIndex, annotationId);
+          }
         }, ignore);
       }
       (_c2 = this.selection) == null ? void 0 : _c2.clear();
     });
   }
-  registerTool(variantKey, defaults) {
+  registerInteractionForTool(tool) {
     var _a, _b;
-    const modeId = defaults.interaction.mode;
-    const interactionMode = {
-      id: modeId,
+    (_a = this.interactionManager) == null ? void 0 : _a.registerMode({
+      id: tool.interaction.mode,
       scope: "page",
-      exclusive: defaults.interaction.exclusive,
-      cursor: defaults.interaction.cursor
-    };
-    (_a = this.interactionManager) == null ? void 0 : _a.registerMode(interactionMode);
-    if (defaults.textSelection) {
-      (_b = this.selection) == null ? void 0 : _b.enableForMode(modeId);
+      exclusive: tool.interaction.exclusive,
+      cursor: tool.interaction.cursor
+    });
+    if (tool.interaction.textSelection) {
+      (_b = this.selection) == null ? void 0 : _b.enableForMode(tool.interaction.mode);
     }
-    this.modeByVariant.set(variantKey, modeId);
-    this.variantByMode.set(modeId, variantKey);
   }
   buildCapability() {
     return {
-      getPageAnnotations: (options) => {
-        return this.getPageAnnotations(options);
-      },
-      getSelectedAnnotation: () => {
-        return getSelectedAnnotation(this.state);
-      },
-      selectAnnotation: (pageIndex, annotationId) => {
-        this.selectAnnotation(pageIndex, annotationId);
-      },
-      deselectAnnotation: () => {
-        this.dispatch(deselectAnnotation());
-      },
-      getActiveVariant: () => {
-        return this.state.activeVariant;
-      },
-      setActiveVariant: (variantKey) => {
-        var _a, _b;
-        if (variantKey === this.state.activeVariant) return;
-        if (variantKey) {
-          const mode = this.modeByVariant.get(variantKey);
-          if (!mode) throw new Error(`Mode missing for variant ${variantKey}`);
-          (_a = this.interactionManager) == null ? void 0 : _a.activate(mode);
-        } else {
-          (_b = this.interactionManager) == null ? void 0 : _b.activateDefaultMode();
-        }
-      },
-      getSubtypeAndIntentByVariant: (variantKey) => {
-        return parseVariantKey(variantKey);
-      },
-      getToolDefaults: (variantKey) => {
-        const defaults = this.state.toolDefaults[variantKey];
-        if (!defaults) {
-          throw new Error(`No defaults found for variant: ${variantKey}`);
-        }
-        return defaults;
-      },
-      getToolDefaultsBySubtypeAndIntent: (subtype, intent) => {
-        return getToolDefaultsBySubtypeAndIntent(this.state, subtype, intent);
-      },
-      getToolDefaultsBySubtype: (subtype) => {
-        return getToolDefaultsBySubtypeAndIntent(this.state, subtype);
-      },
-      setToolDefaults: (variantKey, patch) => {
-        this.dispatch(updateToolDefaults(variantKey, patch));
+      getPageAnnotations: (options) => this.getPageAnnotations(options),
+      getSelectedAnnotation: () => getSelectedAnnotation(this.state),
+      selectAnnotation: (pageIndex, id) => this.selectAnnotation(pageIndex, id),
+      deselectAnnotation: () => this.dispatch(deselectAnnotation()),
+      getActiveTool: () => this.getActiveTool(),
+      setActiveTool: (toolId) => this.setActiveTool(toolId),
+      getTools: () => this.state.tools,
+      getTool: (toolId) => this.getTool(toolId),
+      addTool: (tool) => {
+        this.dispatch(addTool(tool));
+        this.registerInteractionForTool(tool);
       },
+      transformAnnotation: (annotation, options) => this.transformAnnotation(annotation, options),
+      registerPatchFunction: (type, patchFn) => this.registerPatchFunction(type, patchFn),
+      findToolForAnnotation: (anno) => this.findToolForAnnotation(anno),
+      setToolDefaults: (toolId, patch) => this.dispatch(setToolDefaults(toolId, patch)),
       getColorPresets: () => [...this.state.colorPresets],
       addColorPreset: (color) => this.dispatch(addColorPreset(color)),
-      createAnnotation: (pageIndex, annotation, ctx) => this.createAnnotation(pageIndex, annotation, ctx),
+      importAnnotations: (items) => this.importAnnotations(items),
+      createAnnotation: (pageIndex, anno, ctx) => this.createAnnotation(pageIndex, anno, ctx),
       updateAnnotation: (pageIndex, id, patch) => this.updateAnnotation(pageIndex, id, patch),
       deleteAnnotation: (pageIndex, id) => this.deleteAnnotation(pageIndex, id),
       renderAnnotation: (options) => this.renderAnnotation(options),
       onStateChange: this.state$.on,
-      onActiveVariantChange: this.activeVariantChange$.on,
       onActiveToolChange: this.activeTool$.on,
+      onAnnotationEvent: this.events$.on,
       commit: () => this.commit()
     };
   }
-  createActiveTool(mode, toolDefaults) {
-    if (mode === null) {
-      return { variantKey: null, defaults: null };
+  onStoreUpdated(prev, next) {
+    this.state$.emit(next);
+    if (prev.activeToolId !== next.activeToolId || prev.tools !== next.tools) {
+      this.activeTool$.emit(this.getActiveTool());
     }
-    return { variantKey: mode, defaults: toolDefaults[mode] };
   }
-  emitActiveTool(state) {
-    const activeTool = this.createActiveTool(state.activeVariant, state.toolDefaults);
-    this.activeTool$.emit(activeTool);
+  registerPatchFunction(type, patchFn) {
+    this.patchRegistry.register(type, patchFn);
   }
-  onStoreUpdated(prev, next) {
-    this.state$.emit(next);
-    if (prev.activeVariant !== next.activeVariant || prev.toolDefaults[prev.activeVariant ?? PdfAnnotationSubtype.HIGHLIGHT] !== next.toolDefaults[next.activeVariant ?? PdfAnnotationSubtype.HIGHLIGHT]) {
-      this.emitActiveTool(next);
+  transformAnnotation(annotation, options) {
+    const context = {
+      type: options.type,
+      changes: options.changes,
+      metadata: options.metadata
+    };
+    return this.patchRegistry.transform(annotation, context);
+  }
+  registerPageHandlers(pageIndex, scale, callbacks) {
+    var _a;
+    const page = (_a = this.coreState.core.document) == null ? void 0 : _a.pages[pageIndex];
+    if (!page) return () => {
+    };
+    if (!this.interactionManager) return () => {
+    };
+    const unregisterFns = [];
+    for (const tool of this.state.tools) {
+      if (!tool.defaults.type) continue;
+      const factory = this.handlerFactories.get(tool.defaults.type);
+      if (!factory) continue;
+      const context = {
+        pageIndex,
+        pageSize: page.size,
+        scale,
+        services: callbacks.services,
+        // Pass through services
+        onPreview: (state) => callbacks.onPreview(tool.id, state),
+        onCommit: (annotation, ctx) => {
+          this.createAnnotation(pageIndex, annotation, ctx);
+          if (this.getToolBehavior(tool, "deactivateToolAfterCreate")) {
+            this.setActiveTool(null);
+          }
+          if (this.getToolBehavior(tool, "selectAfterCreate")) {
+            this.selectAnnotation(pageIndex, annotation.id);
+          }
+        },
+        getTool: () => this.state.tools.find((t) => t.id === tool.id)
+      };
+      const unregister = this.interactionManager.registerHandlers({
+        modeId: tool.interaction.mode,
+        handlers: factory.create(context),
+        pageIndex
+      });
+      unregisterFns.push(unregister);
     }
+    return () => unregisterFns.forEach((fn) => fn());
   }
   getAllAnnotations(doc) {
     const task = this.engine.getAllAnnotations(doc);
-    task.wait((annotations) => this.dispatch(setAnnotations(annotations)), ignore);
+    task.wait((annotations) => {
+      this.dispatch(setAnnotations(annotations));
+      this.isInitialLoadComplete = true;
+      if (this.importQueue.length > 0) {
+        this.processImportQueue();
+      }
+      this.events$.emit({
+        type: "loaded",
+        total: Object.values(annotations).reduce(
+          (sum, pageAnnotations) => sum + pageAnnotations.length,
+          0
+        )
+      });
+    }, ignore);
   }
   getPageAnnotations(options) {
     const { pageIndex } = options;
@@ -585,16 +1873,36 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
   renderAnnotation({ pageIndex, annotation, options }) {
     const coreState = this.coreState.core;
     if (!coreState.document) {
-      throw new Error("document does not open");
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
     }
     const page = coreState.document.pages.find((page2) => page2.index === pageIndex);
     if (!page) {
-      throw new Error("page does not exist");
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Page not found" });
     }
     return this.engine.renderPageAnnotation(coreState.document, page, annotation, options);
   }
-  selectAnnotation(pageIndex, annotationId) {
-    this.dispatch(selectAnnotation(pageIndex, annotationId));
+  importAnnotations(items) {
+    if (!this.isInitialLoadComplete) {
+      this.importQueue.push(...items);
+      return;
+    }
+    this.processImportItems(items);
+  }
+  processImportQueue() {
+    if (this.importQueue.length === 0) return;
+    const items = [...this.importQueue];
+    this.importQueue = [];
+    this.processImportItems(items);
+  }
+  processImportItems(items) {
+    for (const item of items) {
+      const { annotation, ctx } = item;
+      const pageIndex = annotation.pageIndex;
+      const id = annotation.id;
+      this.dispatch(createAnnotation(pageIndex, annotation));
+      if (ctx) this.pendingContexts.set(id, ctx);
+    }
+    if (this.config.autoCommit !== false) this.commit();
   }
   createAnnotation(pageIndex, annotation, ctx) {
     const id = annotation.id;
@@ -607,6 +1915,7 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
         })
       );
       if (ctx) this.pendingContexts.set(id, ctx);
+      this.events$.emit({ type: "create", annotation, pageIndex, ctx, committed: false });
     };
     if (!this.history) {
       execute();
@@ -619,14 +1928,17 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
         this.pendingContexts.delete(id);
         this.dispatch(deselectAnnotation());
         this.dispatch(deleteAnnotation(pageIndex, id));
+        this.events$.emit({ type: "delete", annotation, pageIndex, committed: false });
       }
     };
     this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
   }
   buildPatch(original, patch) {
     if ("rect" in patch) return patch;
-    const merged = { ...original, ...patch };
-    return { ...patch, rect: deriveRect(merged) };
+    return this.transformAnnotation(original, {
+      type: "property-update",
+      changes: patch
+    });
   }
   updateAnnotation(pageIndex, id, patch) {
     const originalObject = this.state.byUid[id].object;
@@ -634,8 +1946,18 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       ...patch,
       author: patch.author ?? this.config.annotationAuthor
     });
-    if (!this.history) {
+    const execute = () => {
       this.dispatch(patchAnnotation(pageIndex, id, finalPatch));
+      this.events$.emit({
+        type: "update",
+        annotation: originalObject,
+        pageIndex,
+        patch: finalPatch,
+        committed: false
+      });
+    };
+    if (!this.history) {
+      execute();
       if (this.config.autoCommit !== false) {
         this.commit();
       }
@@ -645,30 +1967,85 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
       Object.keys(patch).map((key) => [key, originalObject[key]])
     );
     const command = {
-      execute: () => this.dispatch(patchAnnotation(pageIndex, id, finalPatch)),
-      undo: () => this.dispatch(patchAnnotation(pageIndex, id, originalPatch))
+      execute,
+      undo: () => {
+        this.dispatch(patchAnnotation(pageIndex, id, originalPatch));
+        this.events$.emit({
+          type: "update",
+          annotation: originalObject,
+          pageIndex,
+          patch: originalPatch,
+          committed: false
+        });
+      }
     };
     this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
   }
   deleteAnnotation(pageIndex, id) {
-    if (!this.history) {
+    var _a;
+    const originalAnnotation = (_a = this.state.byUid[id]) == null ? void 0 : _a.object;
+    if (!originalAnnotation) return;
+    const execute = () => {
       this.dispatch(deselectAnnotation());
       this.dispatch(deleteAnnotation(pageIndex, id));
-      if (this.config.autoCommit !== false) {
-        this.commit();
-      }
+      this.events$.emit({
+        type: "delete",
+        annotation: originalAnnotation,
+        pageIndex,
+        committed: false
+      });
+    };
+    if (!this.history) {
+      execute();
+      if (this.config.autoCommit !== false) this.commit();
       return;
     }
-    const originalAnnotation = this.state.byUid[id].object;
     const command = {
-      execute: () => {
-        this.dispatch(deselectAnnotation());
-        this.dispatch(deleteAnnotation(pageIndex, id));
-      },
-      undo: () => this.dispatch(createAnnotation(pageIndex, originalAnnotation))
+      execute,
+      undo: () => {
+        this.dispatch(createAnnotation(pageIndex, originalAnnotation));
+        this.events$.emit({
+          type: "create",
+          annotation: originalAnnotation,
+          pageIndex,
+          committed: false
+        });
+      }
     };
     this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
   }
+  selectAnnotation(pageIndex, id) {
+    this.dispatch(selectAnnotation(pageIndex, id));
+  }
+  getActiveTool() {
+    if (!this.state.activeToolId) return null;
+    return this.state.tools.find((t) => t.id === this.state.activeToolId) ?? null;
+  }
+  setActiveTool(toolId) {
+    var _a, _b;
+    if (toolId === this.state.activeToolId) return;
+    const tool = this.state.tools.find((t) => t.id === toolId);
+    if (tool) {
+      (_a = this.interactionManager) == null ? void 0 : _a.activate(tool.interaction.mode);
+    } else {
+      (_b = this.interactionManager) == null ? void 0 : _b.activateDefaultMode();
+    }
+  }
+  getTool(toolId) {
+    return this.state.tools.find((t) => t.id === toolId);
+  }
+  findToolForAnnotation(annotation) {
+    let bestTool = null;
+    let bestScore = 0;
+    for (const tool of this.state.tools) {
+      const score = tool.matchScore(annotation);
+      if (score > bestScore) {
+        bestScore = score;
+        bestTool = tool;
+      }
+    }
+    return bestTool;
+  }
   commit() {
     const task = new Task();
     if (!this.state.hasPendingChanges) return PdfTaskHelper.resolve(true);
@@ -687,12 +2064,29 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
           const ctx = this.pendingContexts.get(ta.object.id);
           const task2 = this.engine.createPageAnnotation(doc, page, ta.object, ctx);
           task2.wait(() => {
+            this.events$.emit({
+              type: "create",
+              annotation: ta.object,
+              pageIndex: ta.object.pageIndex,
+              ctx,
+              committed: true
+            });
             this.pendingContexts.delete(ta.object.id);
           }, ignore);
           creations.push(task2);
           break;
         case "dirty":
-          updates.push(this.engine.updatePageAnnotation(doc, page, ta.object));
+          const updateTask = this.engine.updatePageAnnotation(doc, page, ta.object);
+          updateTask.wait(() => {
+            this.events$.emit({
+              type: "update",
+              annotation: ta.object,
+              pageIndex: ta.object.pageIndex,
+              patch: ta.object,
+              committed: true
+            });
+          }, ignore);
+          updates.push(updateTask);
           break;
         case "deleted":
           deletions.push({ ta, uid });
@@ -707,6 +2101,12 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
         const removeTask = this.engine.removePageAnnotation(doc, page, ta.object);
         removeTask.wait(() => {
           this.dispatch(purgeAnnotation(uid));
+          this.events$.emit({
+            type: "delete",
+            annotation: ta.object,
+            pageIndex: ta.object.pageIndex,
+            committed: true
+          });
           task2.resolve(true);
         }, task2.fail);
         deletionTasks.push(task2);
@@ -721,189 +2121,301 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     }, task.fail);
     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;
-const DEFAULT_COLORS = [
-  "#E44234",
-  "#FF8D00",
-  "#FFCD45",
-  "#5CC96E",
-  "#25D2D1",
-  "#597CE2",
-  "#C544CE",
-  "#7D2E25",
-  "#000000",
-  "#FFFFFF"
-];
-const patchAnno = (state, uid, patch) => {
-  const prev = state.byUid[uid];
-  if (!prev) return state;
-  return {
-    ...state,
-    byUid: {
-      ...state.byUid,
-      [uid]: {
-        ...prev,
-        commitState: prev.commitState === "synced" ? "dirty" : prev.commitState,
-        object: { ...prev.object, ...patch }
-      }
+const defaultTools = [
+  // Text Markup Tools
+  {
+    id: "highlight",
+    name: "Highlight",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.HIGHLIGHT ? 1 : 0,
+    interaction: {
+      mode: "highlight",
+      exclusive: false,
+      textSelection: true
     },
-    hasPendingChanges: true
-  };
-};
-const initialState = (cfg) => ({
-  pages: {},
-  byUid: {},
-  selectedUid: null,
-  activeVariant: null,
-  toolDefaults: {
-    [makeVariantKey(PdfAnnotationSubtype.HIGHLIGHT)]: {
-      name: "Highlight",
-      subtype: PdfAnnotationSubtype.HIGHLIGHT,
-      interaction: { mode: "highlight", exclusive: false },
-      textSelection: true,
+    defaults: {
+      type: PdfAnnotationSubtype.HIGHLIGHT,
       color: "#FFCD45",
       opacity: 1,
       blendMode: PdfBlendMode.Multiply
+    }
+  },
+  {
+    id: "underline",
+    name: "Underline",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.UNDERLINE ? 1 : 0,
+    interaction: {
+      mode: "underline",
+      exclusive: false,
+      textSelection: true
     },
-    [makeVariantKey(PdfAnnotationSubtype.UNDERLINE)]: {
-      name: "Underline",
-      subtype: PdfAnnotationSubtype.UNDERLINE,
-      interaction: { mode: "underline", exclusive: false },
-      textSelection: true,
+    defaults: {
+      type: PdfAnnotationSubtype.UNDERLINE,
       color: "#E44234",
-      opacity: 1,
-      blendMode: PdfBlendMode.Normal
+      opacity: 1
+    }
+  },
+  {
+    id: "strikeout",
+    name: "Strikeout",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.STRIKEOUT ? 1 : 0,
+    interaction: {
+      mode: "strikeout",
+      exclusive: false,
+      textSelection: true
     },
-    [makeVariantKey(PdfAnnotationSubtype.STRIKEOUT)]: {
-      name: "Strikeout",
-      subtype: PdfAnnotationSubtype.STRIKEOUT,
-      interaction: { mode: "strikeout", exclusive: false },
-      textSelection: true,
+    defaults: {
+      type: PdfAnnotationSubtype.STRIKEOUT,
       color: "#E44234",
-      opacity: 1,
-      blendMode: PdfBlendMode.Normal
+      opacity: 1
+    }
+  },
+  {
+    id: "squiggly",
+    name: "Squiggly",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.SQUIGGLY ? 1 : 0,
+    interaction: {
+      mode: "squiggly",
+      exclusive: false,
+      textSelection: true
     },
-    [makeVariantKey(PdfAnnotationSubtype.SQUIGGLY)]: {
-      name: "Squiggly",
-      subtype: PdfAnnotationSubtype.SQUIGGLY,
-      interaction: { mode: "squiggly", exclusive: false },
-      textSelection: true,
-      color: "#E44234",
-      opacity: 1,
-      blendMode: PdfBlendMode.Normal
+    defaults: {
+      type: PdfAnnotationSubtype.SQUIGGLY,
+      color: "#5CC96E",
+      opacity: 1
+    }
+  },
+  // Drawing Tools
+  {
+    id: "ink",
+    name: "Pen",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent !== "InkHighlight" ? 5 : 0,
+    interaction: {
+      mode: "ink",
+      exclusive: false,
+      cursor: "crosshair"
     },
-    [makeVariantKey(PdfAnnotationSubtype.INK)]: {
-      name: "Ink",
-      subtype: PdfAnnotationSubtype.INK,
-      interaction: { mode: "ink", exclusive: true, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.INK,
       color: "#E44234",
       opacity: 1,
-      strokeWidth: 11,
-      blendMode: PdfBlendMode.Normal
+      strokeWidth: 6
+    }
+  },
+  {
+    id: "inkHighlighter",
+    name: "Ink Highlighter",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.intent === "InkHighlight" ? 10 : 0,
+    interaction: {
+      mode: "inkHighlighter",
+      exclusive: false,
+      cursor: "crosshair"
     },
-    [makeVariantKey(PdfAnnotationSubtype.INK, "InkHighlight")]: {
-      name: "Ink Highlight",
-      subtype: PdfAnnotationSubtype.INK,
+    defaults: {
+      type: PdfAnnotationSubtype.INK,
       intent: "InkHighlight",
-      interaction: { mode: "inkHighlight", exclusive: true, cursor: "crosshair" },
-      color: "#E44234",
+      color: "#FFCD45",
       opacity: 1,
-      strokeWidth: 11,
+      strokeWidth: 14,
       blendMode: PdfBlendMode.Multiply
-    },
-    [makeVariantKey(PdfAnnotationSubtype.CIRCLE)]: {
-      name: "Circle",
-      subtype: PdfAnnotationSubtype.CIRCLE,
-      interaction: { mode: "circle", exclusive: true, cursor: "crosshair" },
+    }
+  },
+  // Shape Tools
+  {
+    id: "circle",
+    name: "Circle",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.CIRCLE ? 1 : 0,
+    interaction: { mode: "circle", exclusive: false, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.CIRCLE,
       color: "transparent",
       opacity: 1,
-      strokeWidth: 4,
+      strokeWidth: 6,
       strokeColor: "#E44234",
       strokeStyle: PdfAnnotationBorderStyle.SOLID
     },
-    [makeVariantKey(PdfAnnotationSubtype.SQUARE)]: {
-      name: "Square",
-      subtype: PdfAnnotationSubtype.SQUARE,
-      interaction: { mode: "square", exclusive: true, cursor: "crosshair" },
+    clickBehavior: {
+      enabled: true,
+      defaultSize: { width: 100, height: 100 }
+    }
+  },
+  {
+    id: "square",
+    name: "Square",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.SQUARE ? 1 : 0,
+    interaction: { mode: "square", exclusive: false, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.SQUARE,
       color: "transparent",
       opacity: 1,
-      strokeWidth: 4,
+      strokeWidth: 6,
       strokeColor: "#E44234",
       strokeStyle: PdfAnnotationBorderStyle.SOLID
     },
-    [makeVariantKey(PdfAnnotationSubtype.LINE)]: {
-      name: "Line",
-      subtype: PdfAnnotationSubtype.LINE,
-      interaction: { mode: "line", exclusive: true, cursor: "crosshair" },
+    clickBehavior: {
+      enabled: true,
+      defaultSize: { width: 100, height: 100 }
+    }
+  },
+  {
+    id: "line",
+    name: "Line",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.LINE && a.intent !== "LineArrow" ? 5 : 0,
+    interaction: { mode: "line", exclusive: false, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.LINE,
       color: "transparent",
       opacity: 1,
-      strokeWidth: 4,
-      strokeColor: "#E44234",
-      strokeStyle: PdfAnnotationBorderStyle.SOLID
+      strokeWidth: 6,
+      strokeColor: "#E44234"
     },
-    [makeVariantKey(PdfAnnotationSubtype.LINE, "LineArrow")]: {
-      name: "Line Arrow",
-      subtype: PdfAnnotationSubtype.LINE,
-      interaction: { mode: "lineArrow", exclusive: true, cursor: "crosshair" },
-      color: "transparent",
+    clickBehavior: {
+      enabled: true,
+      defaultLength: 100,
+      defaultAngle: 0
+    }
+  },
+  {
+    id: "lineArrow",
+    name: "Arrow",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.LINE && a.intent === "LineArrow" ? 10 : 0,
+    interaction: { mode: "lineArrow", exclusive: false, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.LINE,
       intent: "LineArrow",
+      color: "transparent",
       opacity: 1,
-      strokeWidth: 4,
+      strokeWidth: 6,
       strokeColor: "#E44234",
-      strokeStyle: PdfAnnotationBorderStyle.SOLID,
       lineEndings: {
         start: PdfAnnotationLineEnding.None,
         end: PdfAnnotationLineEnding.OpenArrow
       }
     },
-    [makeVariantKey(PdfAnnotationSubtype.POLYLINE)]: {
-      name: "Polyline",
-      subtype: PdfAnnotationSubtype.POLYLINE,
-      interaction: { mode: "polyline", exclusive: true, cursor: "crosshair" },
+    clickBehavior: {
+      enabled: true,
+      defaultLength: 100,
+      defaultAngle: 0
+    }
+  },
+  {
+    id: "polyline",
+    name: "Polyline",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.POLYLINE ? 1 : 0,
+    interaction: { mode: "polyline", exclusive: false, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.POLYLINE,
       color: "transparent",
       opacity: 1,
-      strokeWidth: 4,
-      strokeColor: "#E44234",
-      strokeStyle: PdfAnnotationBorderStyle.SOLID
-    },
-    [makeVariantKey(PdfAnnotationSubtype.POLYGON)]: {
-      name: "Polygon",
-      subtype: PdfAnnotationSubtype.POLYGON,
-      interaction: { mode: "polygon", exclusive: true, cursor: "crosshair" },
+      strokeWidth: 6,
+      strokeColor: "#E44234"
+    }
+  },
+  {
+    id: "polygon",
+    name: "Polygon",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.POLYGON ? 1 : 0,
+    interaction: { mode: "polygon", exclusive: false, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.POLYGON,
       color: "transparent",
       opacity: 1,
-      strokeWidth: 4,
-      strokeColor: "#E44234",
-      strokeStyle: PdfAnnotationBorderStyle.SOLID
-    },
-    [makeVariantKey(PdfAnnotationSubtype.FREETEXT)]: {
-      name: "Free Text",
-      subtype: PdfAnnotationSubtype.FREETEXT,
-      interaction: { mode: "freeText", exclusive: true, cursor: "crosshair" },
-      backgroundColor: "transparent",
-      opacity: 1,
+      strokeWidth: 6,
+      strokeColor: "#E44234"
+    }
+  },
+  // Text & Stamp
+  {
+    id: "freeText",
+    name: "Free Text",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.FREETEXT ? 1 : 0,
+    interaction: { mode: "freeText", exclusive: false, cursor: "crosshair" },
+    defaults: {
+      type: PdfAnnotationSubtype.FREETEXT,
+      contents: "Insert text",
       fontSize: 14,
       fontColor: "#E44234",
-      content: "Insert text here",
       fontFamily: PdfStandardFont.Helvetica,
       textAlign: PdfTextAlignment.Left,
-      verticalAlign: PdfVerticalAlignment.Top
-    },
-    [makeVariantKey(PdfAnnotationSubtype.STAMP)]: {
-      name: "Photo",
-      subtype: PdfAnnotationSubtype.STAMP,
-      interaction: { mode: "stamp", exclusive: true, cursor: "crosshair" }
+      verticalAlign: PdfVerticalAlignment.Top,
+      backgroundColor: "transparent",
+      opacity: 1
     },
-    ...cfg.toolDefaults
+    clickBehavior: {
+      enabled: true,
+      defaultSize: { width: 100, height: 20 },
+      defaultContent: "Insert text"
+    }
   },
-  colorPresets: cfg.colorPresets ?? DEFAULT_COLORS,
-  hasPendingChanges: false
-});
+  {
+    id: "stamp",
+    name: "Image",
+    matchScore: (a) => a.type === PdfAnnotationSubtype.STAMP ? 1 : 0,
+    interaction: { mode: "stamp", exclusive: false, cursor: "copy" },
+    defaults: {
+      type: PdfAnnotationSubtype.STAMP
+      // No imageSrc by default, which tells the UI to open a file picker
+    }
+  }
+];
+const DEFAULT_COLORS = [
+  "#E44234",
+  "#FF8D00",
+  "#FFCD45",
+  "#5CC96E",
+  "#25D2D1",
+  "#597CE2",
+  "#C544CE",
+  "#7D2E25",
+  "#000000",
+  "#FFFFFF"
+];
+const patchAnno = (state, uid, patch) => {
+  const prev = state.byUid[uid];
+  if (!prev) return state;
+  return {
+    ...state,
+    byUid: {
+      ...state.byUid,
+      [uid]: {
+        ...prev,
+        commitState: prev.commitState === "synced" ? "dirty" : prev.commitState,
+        object: { ...prev.object, ...patch }
+      }
+    },
+    hasPendingChanges: true
+  };
+};
+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));
+  return {
+    pages: {},
+    byUid: {},
+    selectedUid: null,
+    activeToolId: null,
+    // `Array.from(toolMap.values())` now correctly returns `AnnotationTool[]`, which matches the state's type.
+    tools: Array.from(toolMap.values()),
+    colorPresets: cfg.colorPresets ?? DEFAULT_COLORS,
+    hasPendingChanges: false
+  };
+};
 const reducer = (state, action) => {
   switch (action.type) {
-    /* ───── bulk load from engine ───── */
     case SET_ANNOTATIONS: {
       const newPages = { ...state.pages };
       const newByUid = { ...state.byUid };
@@ -922,45 +2434,41 @@ const reducer = (state, action) => {
       }
       return { ...state, pages: newPages, byUid: newByUid };
     }
-    /* ───── GUI bits ───── */
-    case SET_ACTIVE_VARIANT:
-      return { ...state, activeVariant: action.payload };
-    case SELECT_ANNOTATION:
+    case SET_ACTIVE_TOOL_ID:
+      return { ...state, activeToolId: action.payload };
+    case ADD_TOOL: {
+      const toolMap = new Map(state.tools.map((t) => [t.id, t]));
+      toolMap.set(action.payload.id, action.payload);
+      return { ...state, tools: Array.from(toolMap.values()) };
+    }
+    case SET_TOOL_DEFAULTS: {
+      const { toolId, patch } = action.payload;
       return {
         ...state,
-        selectedUid: action.payload.id
+        tools: state.tools.map((tool) => {
+          if (tool.id === toolId) {
+            return { ...tool, defaults: { ...tool.defaults, ...patch } };
+          }
+          return tool;
+        })
       };
+    }
+    case SELECT_ANNOTATION:
+      return { ...state, selectedUid: action.payload.id };
     case DESELECT_ANNOTATION:
       return { ...state, selectedUid: null };
     case ADD_COLOR_PRESET:
       return state.colorPresets.includes(action.payload) ? state : { ...state, colorPresets: [...state.colorPresets, action.payload] };
-    case UPDATE_TOOL_DEFAULTS: {
-      const { variantKey, patch } = action.payload;
-      const prev = state.toolDefaults[variantKey];
-      if (!prev) return state;
-      return {
-        ...state,
-        toolDefaults: {
-          ...state.toolDefaults,
-          [variantKey]: { ...prev, ...patch }
-        }
-      };
-    }
-    /* ───── create ───── */
     case CREATE_ANNOTATION: {
       const { pageIndex, annotation } = action.payload;
       const uid = annotation.id;
       return {
         ...state,
         pages: { ...state.pages, [pageIndex]: [...state.pages[pageIndex] ?? [], uid] },
-        byUid: {
-          ...state.byUid,
-          [uid]: { commitState: "new", object: annotation }
-        },
+        byUid: { ...state.byUid, [uid]: { commitState: "new", object: annotation } },
         hasPendingChanges: true
       };
     }
-    /* ───── delete ───── */
     case DELETE_ANNOTATION: {
       const { pageIndex, id: uid } = action.payload;
       if (!state.byUid[uid]) return state;
@@ -977,12 +2485,8 @@ const reducer = (state, action) => {
         hasPendingChanges: true
       };
     }
-    /* ───── field edits ───── */
-    case PATCH_ANNOTATION: {
-      const uid = action.payload.id;
-      return patchAnno(state, uid, action.payload.patch);
-    }
-    /* ───── commit bookkeeping ───── */
+    case PATCH_ANNOTATION:
+      return patchAnno(state, action.payload.id, action.payload.patch);
     case COMMIT_PENDING_CHANGES: {
       const cleaned = {};
       for (const [uid, ta] of Object.entries(state.byUid)) {
@@ -1002,6 +2506,24 @@ const reducer = (state, action) => {
       return state;
   }
 };
+function createToolPredicate(id) {
+  return (tool) => {
+    return (tool == null ? void 0 : tool.id) === id;
+  };
+}
+const isHighlightTool = createToolPredicate("highlight");
+const isSquigglyTool = createToolPredicate("squiggly");
+const isUnderlineTool = createToolPredicate("underline");
+const isStrikeoutTool = createToolPredicate("strikeout");
+const isInkTool = createToolPredicate("ink");
+const isInkHighlighterTool = createToolPredicate("inkHighlighter");
+const isSquareTool = createToolPredicate("square");
+const isCircleTool = createToolPredicate("circle");
+const isLineTool = createToolPredicate("line");
+const isPolylineTool = createToolPredicate("polyline");
+const isPolygonTool = createToolPredicate("polygon");
+const isFreeTextTool = createToolPredicate("freeText");
+const isStampTool = createToolPredicate("stamp");
 const AnnotationPluginPackage = {
   manifest,
   create: (registry, config) => new AnnotationPlugin(ANNOTATION_PLUGIN_ID, registry, config),
@@ -1012,40 +2534,44 @@ export {
   ANNOTATION_PLUGIN_ID,
   AnnotationPlugin,
   AnnotationPluginPackage,
+  createToolPredicate,
   getAnnotations,
   getAnnotationsByPageIndex,
   getSelectedAnnotation,
   getSelectedAnnotationByPageIndex,
-  getSelectedAnnotationVariant,
   getSidebarAnnotationsWithReplies,
   getSidebarAnnotationsWithRepliesGroupedByPage,
-  getToolDefaultsBySubtypeAndIntent,
+  getToolDefaultsById,
   isAnnotationSelected,
   isCircle,
+  isCircleTool,
   isFreeText,
+  isFreeTextTool,
   isHighlight,
-  isHighlightDefaults,
-  isInAnnotationVariant,
+  isHighlightTool,
   isInk,
+  isInkHighlighterTool,
+  isInkTool,
   isLine,
+  isLineTool,
   isPolygon,
+  isPolygonTool,
   isPolyline,
+  isPolylineTool,
   isSidebarAnnotation,
   isSquare,
+  isSquareTool,
   isSquiggly,
-  isSquigglyDefaults,
+  isSquigglyTool,
   isStamp,
+  isStampTool,
   isStrikeout,
-  isStrikeoutDefaults,
+  isStrikeoutTool,
   isText,
   isTextMarkup,
-  isTextMarkupDefaults,
   isUnderline,
-  isUnderlineDefaults,
-  makeVariantKey,
+  isUnderlineTool,
   manifest,
-  parseVariantKey,
-  index as patching,
-  variantKeyFromAnnotation
+  index as patching
 };
 //# sourceMappingURL=index.js.map