@embedpdf/plugin-annotation 1.0.11 → 1.0.13

package/dist/index.js

@@ -1,6 +1,7 @@
-// src/lib/manifest.ts
-var ANNOTATION_PLUGIN_ID = "annotation";
-var manifest = {
+import { BasePlugin, createBehaviorEmitter, SET_DOCUMENT } from "@embedpdf/core";
+import { PdfAnnotationLineEnding, rectFromPoints, expandRect, rotateAndTranslatePoint, PdfAnnotationSubtype, PdfBlendMode, ignore, PdfTaskHelper, PdfErrorCode, Rotation, AppearanceMode, Task, PdfAnnotationBorderStyle } from "@embedpdf/models";
+const ANNOTATION_PLUGIN_ID = "annotation";
+const manifest = {
   id: ANNOTATION_PLUGIN_ID,
   name: "Annotation Plugin",
   version: "1.0.0",
@@ -12,104 +13,87 @@ var manifest = {
     autoCommit: true
   }
 };
-
-// src/lib/annotation-plugin.ts
-import {
-  BasePlugin,
-  createBehaviorEmitter,
-  enumEntries,
-  SET_DOCUMENT
-} from "@embedpdf/core";
-import {
-  ignore,
-  Task,
-  PdfAnnotationSubtype,
-  PdfTaskHelper,
-  PdfErrorCode,
-  Rotation,
-  AppearanceMode
-} from "@embedpdf/models";
-
-// src/lib/actions.ts
-var SET_ANNOTATIONS = "ANNOTATION/SET_ANNOTATIONS";
-var REINDEX_PAGE_ANNOTATIONS = "ANNOTATION/REINDEX_PAGE";
-var SELECT_ANNOTATION = "ANNOTATION/SELECT_ANNOTATION";
-var DESELECT_ANNOTATION = "ANNOTATION/DESELECT_ANNOTATION";
-var SET_ANNOTATION_MODE = "ANNOTATION/SET_ANNOTATION_MODE";
-var UPDATE_TOOL_DEFAULTS = "ANNOTATION/UPDATE_TOOL_DEFAULTS";
-var ADD_COLOR_PRESET = "ANNOTATION/ADD_COLOR_PRESET";
-var CREATE_ANNOTATION = "ANNOTATION/CREATE_ANNOTATION";
-var PATCH_ANNOTATION = "ANNOTATION/PATCH_ANNOTATION";
-var DELETE_ANNOTATION = "ANNOTATION/DELETE_ANNOTATION";
-var COMMIT_PENDING_CHANGES = "ANNOTATION/COMMIT";
-var STORE_PDF_ID = "ANNOTATION/STORE_PDF_ID";
-var PURGE_ANNOTATION = "ANNOTATION/PURGE_ANNOTATION";
-var setAnnotations = (p) => ({
+const SET_ANNOTATIONS = "ANNOTATION/SET_ANNOTATIONS";
+const REINDEX_PAGE_ANNOTATIONS = "ANNOTATION/REINDEX_PAGE";
+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 STORE_PDF_ID = "ANNOTATION/STORE_PDF_ID";
+const PURGE_ANNOTATION = "ANNOTATION/PURGE_ANNOTATION";
+const SET_ACTIVE_VARIANT = "ANNOTATION/SET_ACTIVE_VARIANT";
+const setAnnotations = (p) => ({
   type: SET_ANNOTATIONS,
   payload: p
 });
-var reindexPageAnnotations = (pageIndex) => ({
+const reindexPageAnnotations = (pageIndex) => ({
   type: REINDEX_PAGE_ANNOTATIONS,
   payload: { pageIndex }
 });
-var selectAnnotation = (pageIndex, localId) => ({
+const selectAnnotation = (pageIndex, localId) => ({
   type: SELECT_ANNOTATION,
   payload: { pageIndex, localId }
 });
-var deselectAnnotation = () => ({ type: DESELECT_ANNOTATION });
-var setAnnotationMode = (m) => ({
-  type: SET_ANNOTATION_MODE,
-  payload: m
-});
-var updateToolDefaults = (subtype, patch) => ({ type: UPDATE_TOOL_DEFAULTS, payload: { subtype, patch } });
-var addColorPreset = (c) => ({
+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
 });
-var createAnnotation = (pageIndex, localId, annotation) => ({
+const createAnnotation = (pageIndex, localId, annotation) => ({
   type: CREATE_ANNOTATION,
   payload: { pageIndex, localId, annotation }
 });
-var patchAnnotation = (pageIndex, localId, patch) => ({
+const patchAnnotation = (pageIndex, localId, patch) => ({
   type: PATCH_ANNOTATION,
   payload: { pageIndex, localId, patch }
 });
-var deleteAnnotation = (pageIndex, localId) => ({
+const deleteAnnotation = (pageIndex, localId) => ({
   type: DELETE_ANNOTATION,
   payload: { pageIndex, localId }
 });
-var commitPendingChanges = () => ({ type: COMMIT_PENDING_CHANGES });
-var storePdfId = (uid, pdfId) => ({
+const commitPendingChanges = () => ({ type: COMMIT_PENDING_CHANGES });
+const storePdfId = (uid, pdfId) => ({
   type: STORE_PDF_ID,
   payload: { uid, pdfId }
 });
-var purgeAnnotation = (uid) => ({
+const purgeAnnotation = (uid) => ({
   type: PURGE_ANNOTATION,
   payload: { uid }
 });
-
-// src/lib/utils.ts
-var makeUid = (pageIndex, localId) => `p${pageIndex}#${localId}`;
-var parseUid = (uid) => {
+const setActiveVariant = (k) => ({
+  type: SET_ACTIVE_VARIANT,
+  payload: k
+});
+const makeUid$1 = (pageIndex, localId) => `p${pageIndex}#${localId}`;
+const parseUid = (uid) => {
   const [pg, rest] = uid.slice(1).split("#");
   return { pageIndex: Number(pg), localId: Number(rest) };
 };
-
-// src/lib/selectors.ts
-var makeUid2 = (page, id) => `p${page}#${id}`;
-var getAnnotationsByPageIndex = (s, page) => (s.pages[page] ?? []).map((uid) => s.byUid[uid]);
-var getAnnotations = (s) => {
+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 makeUid = (page, id) => `p${page}#${id}`;
+const getAnnotationsByPageIndex = (s, page) => (s.pages[page] ?? []).map((uid) => s.byUid[uid]);
+const getAnnotations = (s) => {
   const out = {};
   for (const p of Object.keys(s.pages).map(Number)) out[p] = getAnnotationsByPageIndex(s, p);
   return out;
 };
-var getSelectedAnnotation = (s) => s.selectedUid ? s.byUid[s.selectedUid] : null;
-var getSelectedAnnotationWithPageIndex = (s) => {
+const getSelectedAnnotation = (s) => s.selectedUid ? s.byUid[s.selectedUid] : null;
+const getSelectedAnnotationWithPageIndex = (s) => {
   if (!s.selectedUid) return null;
   const { pageIndex, localId } = parseUid(s.selectedUid);
   return { pageIndex, localId, annotation: s.byUid[s.selectedUid].object };
 };
-var getSelectedAnnotationByPageIndex = (s, pageIndex) => {
+const getSelectedAnnotationByPageIndex = (s, pageIndex) => {
   if (!s.selectedUid) return null;
   const pageUids = s.pages[pageIndex] ?? [];
   if (pageUids.includes(s.selectedUid)) {
@@ -117,33 +101,240 @@ var getSelectedAnnotationByPageIndex = (s, pageIndex) => {
   }
   return null;
 };
-var isInAnnotationMode = (s) => s.annotationMode !== null;
-var getSelectedAnnotationMode = (s) => s.annotationMode;
-var isAnnotationSelected = (s, page, id) => s.selectedUid === makeUid2(page, id);
-
-// src/lib/annotation-plugin.ts
-var AnnotationPlugin = class extends BasePlugin {
+const isInAnnotationVariant = (s) => s.activeVariant !== null;
+const getSelectedAnnotationVariant = (s) => s.activeVariant;
+const isAnnotationSelected = (s, page, id) => s.selectedUid === makeUid(page, 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 createArrowHandler(isClosed) {
+  const calculateGeometry = (sw) => {
+    const len = sw * 9;
+    const a = Math.PI / 6;
+    return {
+      x: -len * Math.cos(a),
+      y: len * Math.sin(a)
+    };
+  };
+  return {
+    getSvgPath: (sw) => {
+      const { x, y } = calculateGeometry(sw);
+      return isClosed ? `M 0 0 L ${x} ${y} L ${x} ${-y} Z` : `M ${x} ${y} L 0 0 L ${x} ${-y}`;
+    },
+    getLocalPoints: (sw) => {
+      const { x, y } = calculateGeometry(sw);
+      return [
+        { x: 0, y: 0 },
+        { x, y },
+        { x, y: -y }
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    filled: isClosed
+  };
+}
+function createLineHandler(lengthFactor, rotationFn) {
+  const getHalfLength = (sw) => sw * lengthFactor / 2;
+  return {
+    getSvgPath: (sw) => {
+      const l = getHalfLength(sw);
+      return `M ${-l} 0 L ${l} 0`;
+    },
+    getLocalPoints: (sw) => {
+      const l = getHalfLength(sw);
+      return [
+        { x: -l, y: 0 },
+        { x: l, y: 0 }
+      ];
+    },
+    getRotation: rotationFn,
+    filled: false
+  };
+}
+const OpenArrowHandler = createArrowHandler(false);
+const ClosedArrowHandler = createArrowHandler(true);
+const LINE_ENDING_HANDLERS = {
+  [PdfAnnotationLineEnding.OpenArrow]: OpenArrowHandler,
+  [PdfAnnotationLineEnding.ClosedArrow]: ClosedArrowHandler,
+  [PdfAnnotationLineEnding.ROpenArrow]: {
+    ...OpenArrowHandler,
+    getRotation: (segmentAngle) => segmentAngle + Math.PI
+  },
+  [PdfAnnotationLineEnding.RClosedArrow]: {
+    ...ClosedArrowHandler,
+    getRotation: (segmentAngle) => segmentAngle + Math.PI
+  },
+  [PdfAnnotationLineEnding.Circle]: {
+    getSvgPath: (sw) => {
+      const r = sw * 5 / 2;
+      return `M ${r} 0 A ${r} ${r} 0 1 1 ${-r} 0 A ${r} ${r} 0 1 1 ${r} 0`;
+    },
+    getLocalPoints: (sw) => {
+      const r = sw * 5 / 2;
+      return [
+        { x: -r, y: -r },
+        { x: r, y: r }
+      ];
+    },
+    getRotation: () => 0,
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Square]: {
+    getSvgPath: (sw) => {
+      const h = sw * 6 / 2;
+      return `M ${-h} ${-h} L ${h} ${-h} L ${h} ${h} L ${-h} ${h} Z`;
+    },
+    getLocalPoints: (sw) => {
+      const h = sw * 6 / 2;
+      return [
+        { x: -h, y: -h },
+        // TL
+        { x: h, y: -h },
+        // TR
+        { x: h, y: h },
+        // BR
+        { x: -h, y: h }
+        // BL
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    // keep your new orientation
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Diamond]: {
+    getSvgPath: (sw) => {
+      const h = sw * 6 / 2;
+      return `M 0 ${-h} L ${h} 0 L 0 ${h} L ${-h} 0 Z`;
+    },
+    getLocalPoints: (sw) => {
+      const h = sw * 6 / 2;
+      return [
+        { x: 0, y: -h },
+        { x: h, y: 0 },
+        { x: 0, y: h },
+        { x: -h, y: 0 }
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Butt]: createLineHandler(6, (angle) => angle + Math.PI / 2),
+  [PdfAnnotationLineEnding.Slash]: createLineHandler(18, (angle) => angle + Math.PI / 1.5)
+};
+const EXTRA_PADDING = 1.2;
+function lineRectWithEndings(vertices, strokeWidth, endings) {
+  if (!vertices || vertices.length === 0) {
+    return { origin: { x: 0, y: 0 }, size: { width: 0, height: 0 } };
+  }
+  const allPoints = [...vertices];
+  const toAngle = (a, b) => Math.atan2(b.y - a.y, b.x - a.x);
+  const processEnding = (endingType, tipPos, segmentAngle) => {
+    if (!endingType) return;
+    const handler = LINE_ENDING_HANDLERS[endingType];
+    if (!handler) return;
+    const localPts = handler.getLocalPoints(strokeWidth);
+    const rotationAngle = handler.getRotation(segmentAngle);
+    const transformedPts = localPts.map((p) => rotateAndTranslatePoint(p, rotationAngle, tipPos));
+    allPoints.push(...transformedPts);
+  };
+  if (vertices.length >= 2) {
+    const startAngle = toAngle(vertices[1], vertices[0]);
+    processEnding(endings == null ? void 0 : endings.start, vertices[0], startAngle);
+    const lastIdx = vertices.length - 1;
+    const endAngle = toAngle(vertices[lastIdx - 1], vertices[lastIdx]);
+    processEnding(endings == null ? void 0 : endings.end, vertices[lastIdx], endAngle);
+  }
+  if (allPoints.length <= 1) {
+    const point = vertices[0] || { x: 0, y: 0 };
+    const pad2 = strokeWidth;
+    return {
+      origin: { x: point.x - pad2, y: point.y - pad2 },
+      size: { width: pad2 * 2, height: pad2 * 2 }
+    };
+  }
+  const baseRect = rectFromPoints(allPoints);
+  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];
+  if (!handler) return null;
+  const toDeg = (r) => r * 180 / Math.PI;
+  const rotationAngle = handler.getRotation(rad);
+  return {
+    d: handler.getSvgPath(strokeWidth),
+    transform: `translate(${px} ${py}) rotate(${toDeg(rotationAngle)})`,
+    filled: handler.filled
+  };
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  LINE_ENDING_HANDLERS,
+  createEnding,
+  deriveRect,
+  lineRectWithEndings
+}, Symbol.toStringTag, { value: "Module" }));
+const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
   constructor(id, registry, engine, config) {
     super(id, registry);
     this.ANNOTATION_HISTORY_TOPIC = "annotations";
     this.state$ = createBehaviorEmitter();
-    /** Map <subtype> → <modeId>.  Filled once in `initialize()`. */
-    this.modeBySubtype = /* @__PURE__ */ new Map();
-    /** The inverse map for quick lookup in onModeChange().          */
-    this.subtypeByMode = /* @__PURE__ */ new Map();
-    this.modeChange$ = createBehaviorEmitter();
+    this.modeByVariant = /* @__PURE__ */ new Map();
+    this.variantByMode = /* @__PURE__ */ new Map();
+    this.activeVariantChange$ = createBehaviorEmitter();
     this.activeTool$ = createBehaviorEmitter({
-      mode: null,
+      variantKey: null,
       defaults: null
     });
     this.engine = engine;
     this.config = config;
     const selection = registry.getPlugin("selection");
-    this.selection = selection?.provides() ?? null;
+    this.selection = (selection == null ? void 0 : selection.provides()) ?? null;
     const history = registry.getPlugin("history");
-    this.history = history?.provides() ?? null;
+    this.history = (history == null ? void 0 : history.provides()) ?? null;
     const interactionManager = registry.getPlugin("interaction-manager");
-    this.interactionManager = interactionManager?.provides() ?? null;
+    this.interactionManager = (interactionManager == null ? void 0 : interactionManager.provides()) ?? null;
     this.coreStore.onAction(SET_DOCUMENT, (_action, state) => {
       const doc = state.core.document;
       if (doc) {
@@ -152,48 +343,55 @@ var AnnotationPlugin = class extends BasePlugin {
     });
   }
   async initialize() {
-    for (const [subtype, defaults] of enumEntries(this.state.toolDefaults)) {
-      this.registerTool(subtype, defaults);
+    var _a, _b, _c;
+    for (const [variantKey, defaults] of Object.entries(this.state.toolDefaults)) {
+      this.registerTool(variantKey, defaults);
     }
-    this.history?.onHistoryChange((topic) => {
+    (_a = this.history) == null ? void 0 : _a.onHistoryChange((topic) => {
       if (topic === this.ANNOTATION_HISTORY_TOPIC && this.config.autoCommit !== false) {
         this.commit();
       }
     });
-    this.interactionManager?.onModeChange((s) => {
-      const newSubtype = this.subtypeByMode.get(s.activeMode) ?? null;
-      if (newSubtype !== this.state.annotationMode) {
-        this.dispatch(setAnnotationMode(newSubtype));
-        this.modeChange$.emit(newSubtype);
+    (_b = this.interactionManager) == null ? void 0 : _b.onModeChange((s) => {
+      const newVariant = this.variantByMode.get(s.activeMode) ?? null;
+      console.log(newVariant, this.state.activeVariant);
+      if (newVariant !== this.state.activeVariant) {
+        this.dispatch(setActiveVariant(newVariant));
+        this.activeVariantChange$.emit(newVariant);
       }
     });
-    this.selection?.onEndSelection(() => {
-      if (!this.state.annotationMode) return;
-      if (!(this.state.annotationMode === PdfAnnotationSubtype.HIGHLIGHT || this.state.annotationMode === PdfAnnotationSubtype.UNDERLINE || this.state.annotationMode === PdfAnnotationSubtype.STRIKEOUT || this.state.annotationMode === PdfAnnotationSubtype.SQUIGGLY)) {
+    (_c = this.selection) == null ? void 0 : _c.onEndSelection(() => {
+      var _a2, _b2;
+      if (!this.state.activeVariant) return;
+      if (!(this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.HIGHLIGHT) || this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.UNDERLINE) || this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.STRIKEOUT) || this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.SQUIGGLY))) {
         return;
       }
-      const formattedSelection = this.selection?.getFormattedSelection();
+      const formattedSelection = (_a2 = this.selection) == null ? void 0 : _a2.getFormattedSelection();
       if (!formattedSelection) return;
       for (const selection of formattedSelection) {
         const rect = selection.rect;
         const segmentRects = selection.segmentRects;
-        const type = this.state.annotationMode;
+        const type = this.state.activeVariant;
+        const subtype = this.state.toolDefaults[type].subtype;
         const color = this.state.toolDefaults[type].color;
         const opacity = this.state.toolDefaults[type].opacity;
+        const blendMode = this.state.toolDefaults[type].blendMode ?? PdfBlendMode.Normal;
         this.createAnnotation(selection.pageIndex, {
-          type,
+          type: subtype,
           rect,
           segmentRects,
           color,
           opacity,
+          blendMode,
           pageIndex: selection.pageIndex,
           id: Date.now() + Math.random()
         });
       }
-      this.selection?.clear();
+      (_b2 = this.selection) == null ? void 0 : _b2.clear();
     });
   }
-  registerTool(subtype, defaults) {
+  registerTool(variantKey, defaults) {
+    var _a, _b;
     const modeId = defaults.interaction.mode;
     const interactionMode = {
       id: modeId,
@@ -201,12 +399,12 @@ var AnnotationPlugin = class extends BasePlugin {
       exclusive: defaults.interaction.exclusive,
       cursor: defaults.interaction.cursor
     };
-    this.interactionManager?.registerMode(interactionMode);
+    (_a = this.interactionManager) == null ? void 0 : _a.registerMode(interactionMode);
     if (defaults.textSelection) {
-      this.selection?.enableForMode(modeId);
+      (_b = this.selection) == null ? void 0 : _b.enableForMode(modeId);
     }
-    this.modeBySubtype.set(subtype, modeId);
-    this.subtypeByMode.set(modeId, subtype);
+    this.modeByVariant.set(variantKey, modeId);
+    this.variantByMode.set(modeId, variantKey);
   }
   buildCapability() {
     return {
@@ -222,28 +420,38 @@ var AnnotationPlugin = class extends BasePlugin {
       deselectAnnotation: () => {
         this.dispatch(deselectAnnotation());
       },
-      getAnnotationMode: () => {
-        return this.state.annotationMode;
+      getActiveVariant: () => {
+        return this.state.activeVariant;
       },
-      setAnnotationMode: (subtype) => {
-        if (subtype === this.state.annotationMode) return;
-        if (subtype) {
-          const mode = this.modeBySubtype.get(subtype);
-          if (!mode) throw new Error(`Mode missing for subtype ${subtype}`);
-          this.interactionManager?.activate(mode);
+      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 {
-          this.interactionManager?.activate("default");
+          (_b = this.interactionManager) == null ? void 0 : _b.activate("default");
         }
       },
-      getToolDefaults: (subtype) => {
-        const defaults = this.state.toolDefaults[subtype];
+      getSubtypeAndIntentByVariant: (variantKey) => {
+        return parseVariantKey(variantKey);
+      },
+      getToolDefaults: (variantKey) => {
+        const defaults = this.state.toolDefaults[variantKey];
         if (!defaults) {
-          throw new Error(`No defaults found for subtype: ${subtype}`);
+          throw new Error(`No defaults found for variant: ${variantKey}`);
         }
         return defaults;
       },
-      setToolDefaults: (subtype, patch) => {
-        this.dispatch(updateToolDefaults(subtype, patch));
+      getToolDefaultsBySubtypeAndIntent: (subtype, intent) => {
+        return getToolDefaultsBySubtypeAndIntent(this.state, subtype, intent);
+      },
+      getToolDefaultsBySubtype: (subtype) => {
+        return getToolDefaultsBySubtypeAndIntent(this.state, subtype);
+      },
+      setToolDefaults: (variantKey, patch) => {
+        this.dispatch(updateToolDefaults(variantKey, patch));
       },
       getColorPresets: () => [...this.state.colorPresets],
       addColorPreset: (color) => this.dispatch(addColorPreset(color)),
@@ -252,24 +460,24 @@ var AnnotationPlugin = class extends BasePlugin {
       deleteAnnotation: (pageIndex, localId) => this.deleteAnnotation(pageIndex, localId),
       renderAnnotation: (options) => this.renderAnnotation(options),
       onStateChange: this.state$.on,
-      onModeChange: this.modeChange$.on,
+      onActiveVariantChange: this.activeVariantChange$.on,
       onActiveToolChange: this.activeTool$.on,
       commit: () => this.commit()
     };
   }
   createActiveTool(mode, toolDefaults) {
     if (mode === null) {
-      return { mode: null, defaults: null };
+      return { variantKey: null, defaults: null };
     }
-    return { mode, defaults: toolDefaults[mode] };
+    return { variantKey: mode, defaults: toolDefaults[mode] };
   }
   emitActiveTool(state) {
-    const activeTool = this.createActiveTool(state.annotationMode, state.toolDefaults);
+    const activeTool = this.createActiveTool(state.activeVariant, state.toolDefaults);
     this.activeTool$.emit(activeTool);
   }
   onStoreUpdated(prev, next) {
     this.state$.emit(next);
-    if (prev.annotationMode !== next.annotationMode || prev.toolDefaults[prev.annotationMode ?? PdfAnnotationSubtype.HIGHLIGHT] !== next.toolDefaults[next.annotationMode ?? PdfAnnotationSubtype.HIGHLIGHT]) {
+    if (prev.activeVariant !== next.activeVariant || prev.toolDefaults[prev.activeVariant ?? PdfAnnotationSubtype.HIGHLIGHT] !== next.toolDefaults[next.activeVariant ?? PdfAnnotationSubtype.HIGHLIGHT]) {
       this.emitActiveTool(next);
     }
   }
@@ -337,20 +545,26 @@ var AnnotationPlugin = class extends BasePlugin {
     };
     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) };
+  }
   updateAnnotation(pageIndex, localId, patch) {
+    const originalObject = this.state.byUid[makeUid$1(pageIndex, localId)].object;
+    const finalPatch = this.buildPatch(originalObject, patch);
     if (!this.history) {
-      this.dispatch(patchAnnotation(pageIndex, localId, patch));
+      this.dispatch(patchAnnotation(pageIndex, localId, finalPatch));
       if (this.config.autoCommit !== false) {
         this.commit();
       }
       return;
     }
-    const originalObject = this.state.byUid[makeUid(pageIndex, localId)].object;
     const originalPatch = Object.fromEntries(
       Object.keys(patch).map((key) => [key, originalObject[key]])
     );
     const command = {
-      execute: () => this.dispatch(patchAnnotation(pageIndex, localId, patch)),
+      execute: () => this.dispatch(patchAnnotation(pageIndex, localId, finalPatch)),
       undo: () => this.dispatch(patchAnnotation(pageIndex, localId, originalPatch))
     };
     this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
@@ -364,7 +578,7 @@ var AnnotationPlugin = class extends BasePlugin {
       }
       return;
     }
-    const originalAnnotation = this.state.byUid[makeUid(pageIndex, localId)].object;
+    const originalAnnotation = this.state.byUid[makeUid$1(pageIndex, localId)].object;
     const command = {
       execute: () => {
         this.dispatch(deselectAnnotation());
@@ -441,11 +655,9 @@ var AnnotationPlugin = class extends BasePlugin {
     return task;
   }
 };
-AnnotationPlugin.id = "annotation";
-
-// src/lib/reducer.ts
-import { PdfAnnotationSubtype as PdfAnnotationSubtype2 } from "@embedpdf/models";
-var DEFAULT_COLORS = [
+_AnnotationPlugin.id = "annotation";
+let AnnotationPlugin = _AnnotationPlugin;
+const DEFAULT_COLORS = [
   "#E44234",
   "#FF8D00",
   "#FFCD45",
@@ -455,7 +667,7 @@ var DEFAULT_COLORS = [
   "#C544CE",
   "#7D2E25"
 ];
-var patchAnno = (state, uid, patch) => {
+const patchAnno = (state, uid, patch) => {
   const prev = state.byUid[uid];
   if (!prev) return state;
   return {
@@ -471,54 +683,138 @@ var patchAnno = (state, uid, patch) => {
     hasPendingChanges: true
   };
 };
-var initialState = (cfg) => ({
+const initialState = (cfg) => ({
   pages: {},
   byUid: {},
   selectedUid: null,
-  annotationMode: null,
+  activeVariant: null,
   toolDefaults: {
-    [PdfAnnotationSubtype2.HIGHLIGHT]: {
+    [makeVariantKey(PdfAnnotationSubtype.HIGHLIGHT)]: {
       name: "Highlight",
+      subtype: PdfAnnotationSubtype.HIGHLIGHT,
+      interaction: { mode: "highlight", exclusive: false },
+      textSelection: true,
       color: "#FFCD45",
       opacity: 1,
-      interaction: { mode: "highlight", exclusive: false },
-      textSelection: true
+      blendMode: PdfBlendMode.Multiply
     },
-    [PdfAnnotationSubtype2.UNDERLINE]: {
+    [makeVariantKey(PdfAnnotationSubtype.UNDERLINE)]: {
       name: "Underline",
+      subtype: PdfAnnotationSubtype.UNDERLINE,
+      interaction: { mode: "underline", exclusive: false },
+      textSelection: true,
       color: "#E44234",
       opacity: 1,
-      interaction: { mode: "underline", exclusive: false },
-      textSelection: true
+      blendMode: PdfBlendMode.Normal
     },
-    [PdfAnnotationSubtype2.STRIKEOUT]: {
+    [makeVariantKey(PdfAnnotationSubtype.STRIKEOUT)]: {
       name: "Strikeout",
+      subtype: PdfAnnotationSubtype.STRIKEOUT,
+      interaction: { mode: "strikeout", exclusive: false },
+      textSelection: true,
       color: "#E44234",
       opacity: 1,
-      interaction: { mode: "strikeout", exclusive: false },
-      textSelection: true
+      blendMode: PdfBlendMode.Normal
     },
-    [PdfAnnotationSubtype2.SQUIGGLY]: {
+    [makeVariantKey(PdfAnnotationSubtype.SQUIGGLY)]: {
       name: "Squiggly",
+      subtype: PdfAnnotationSubtype.SQUIGGLY,
+      interaction: { mode: "squiggly", exclusive: false },
+      textSelection: true,
       color: "#E44234",
       opacity: 1,
-      interaction: { mode: "squiggly", exclusive: false },
-      textSelection: true
+      blendMode: PdfBlendMode.Normal
     },
-    [PdfAnnotationSubtype2.INK]: {
+    [makeVariantKey(PdfAnnotationSubtype.INK)]: {
       name: "Ink",
+      subtype: PdfAnnotationSubtype.INK,
+      interaction: { mode: "ink", exclusive: true, cursor: "crosshair" },
       color: "#E44234",
       opacity: 1,
       strokeWidth: 11,
-      interaction: { mode: "ink", exclusive: true, cursor: "crosshair" },
-      textSelection: false
+      blendMode: PdfBlendMode.Normal
+    },
+    [makeVariantKey(PdfAnnotationSubtype.INK, "InkHighlight")]: {
+      name: "Ink Highlight",
+      subtype: PdfAnnotationSubtype.INK,
+      intent: "InkHighlight",
+      interaction: { mode: "inkHighlight", exclusive: true, cursor: "crosshair" },
+      color: "#E44234",
+      opacity: 1,
+      strokeWidth: 11,
+      blendMode: PdfBlendMode.Multiply
+    },
+    [makeVariantKey(PdfAnnotationSubtype.CIRCLE)]: {
+      name: "Circle",
+      subtype: PdfAnnotationSubtype.CIRCLE,
+      interaction: { mode: "circle", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.SQUARE)]: {
+      name: "Square",
+      subtype: PdfAnnotationSubtype.SQUARE,
+      interaction: { mode: "square", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.LINE)]: {
+      name: "Line",
+      subtype: PdfAnnotationSubtype.LINE,
+      interaction: { mode: "line", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.LINE, "LineArrow")]: {
+      name: "Line Arrow",
+      subtype: PdfAnnotationSubtype.LINE,
+      interaction: { mode: "lineArrow", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      intent: "LineArrow",
+      opacity: 1,
+      strokeWidth: 4,
+      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" },
+      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" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
     },
     ...cfg.toolDefaults
   },
   colorPresets: cfg.colorPresets ?? DEFAULT_COLORS,
   hasPendingChanges: false
 });
-var reducer = (state, action) => {
+const reducer = (state, action) => {
   switch (action.type) {
     /* ───── bulk load from engine ───── */
     case SET_ANNOTATIONS: {
@@ -530,9 +826,9 @@ var reducer = (state, action) => {
         for (const uid of oldUidsOnPage) {
           delete newByUid[uid];
         }
-        const newUidsOnPage = list.map((a, index) => {
-          const localId = Date.now() + Math.random() + index;
-          const uid = makeUid(pageIndex, localId);
+        const newUidsOnPage = list.map((a, index2) => {
+          const localId = Date.now() + Math.random() + index2;
+          const uid = makeUid$1(pageIndex, localId);
           newByUid[uid] = { localId, pdfId: a.id, commitState: "synced", object: a };
           return uid;
         });
@@ -541,31 +837,33 @@ var reducer = (state, action) => {
       return { ...state, pages: newPages, byUid: newByUid };
     }
     /* ───── GUI bits ───── */
-    case SET_ANNOTATION_MODE:
-      return { ...state, annotationMode: action.payload };
+    case SET_ACTIVE_VARIANT:
+      return { ...state, activeVariant: action.payload };
     case SELECT_ANNOTATION:
       return {
         ...state,
-        selectedUid: makeUid(action.payload.pageIndex, action.payload.localId)
+        selectedUid: makeUid$1(action.payload.pageIndex, action.payload.localId)
       };
     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 { subtype, patch } = action.payload;
+      const { variantKey, patch } = action.payload;
+      const prev = state.toolDefaults[variantKey];
+      if (!prev) return state;
       return {
         ...state,
         toolDefaults: {
           ...state.toolDefaults,
-          [subtype]: { ...state.toolDefaults[subtype], ...patch }
+          [variantKey]: { ...prev, ...patch }
         }
       };
     }
     /* ───── create ───── */
     case CREATE_ANNOTATION: {
       const { pageIndex, localId, annotation } = action.payload;
-      const uid = makeUid(pageIndex, localId);
+      const uid = makeUid$1(pageIndex, localId);
       return {
         ...state,
         pages: { ...state.pages, [pageIndex]: [...state.pages[pageIndex] ?? [], uid] },
@@ -579,7 +877,7 @@ var reducer = (state, action) => {
     /* ───── delete ───── */
     case DELETE_ANNOTATION: {
       const { pageIndex, localId } = action.payload;
-      const uid = makeUid(pageIndex, localId);
+      const uid = makeUid$1(pageIndex, localId);
       if (!state.byUid[uid]) return state;
       return {
         ...state,
@@ -596,7 +894,7 @@ var reducer = (state, action) => {
     }
     /* ───── field edits ───── */
     case PATCH_ANNOTATION: {
-      const uid = makeUid(action.payload.pageIndex, action.payload.localId);
+      const uid = makeUid$1(action.payload.pageIndex, action.payload.localId);
       return patchAnno(state, uid, action.payload.patch);
     }
     /* ───── commit bookkeeping ───── */
@@ -617,7 +915,7 @@ var reducer = (state, action) => {
       const annosOnPage = uidsOnPage.map((uid) => state.byUid[uid]).filter((ta) => ta && ta.commitState !== "deleted");
       annosOnPage.sort((a, b) => (a.pdfId ?? Infinity) - (b.pdfId ?? Infinity));
       annosOnPage.forEach((ta, newPdfId) => {
-        const uid = makeUid(pageIndex, ta.localId);
+        const uid = makeUid$1(pageIndex, ta.localId);
         newByUid[uid] = { ...newByUid[uid], pdfId: newPdfId };
       });
       return { ...state, byUid: newByUid };
@@ -643,9 +941,40 @@ var reducer = (state, action) => {
       return state;
   }
 };
-
-// src/lib/index.ts
-var AnnotationPluginPackage = {
+function isInk(a) {
+  return a.object.type === PdfAnnotationSubtype.INK;
+}
+function isCircle(a) {
+  return a.object.type === PdfAnnotationSubtype.CIRCLE;
+}
+function isPolygon(a) {
+  return a.object.type === PdfAnnotationSubtype.POLYGON;
+}
+function isSquare(a) {
+  return a.object.type === PdfAnnotationSubtype.SQUARE;
+}
+function isLine(a) {
+  return a.object.type === PdfAnnotationSubtype.LINE;
+}
+function isPolyline(a) {
+  return a.object.type === PdfAnnotationSubtype.POLYLINE;
+}
+function isTextMarkup(a) {
+  return a.object.type === PdfAnnotationSubtype.HIGHLIGHT || a.object.type === PdfAnnotationSubtype.UNDERLINE || a.object.type === PdfAnnotationSubtype.STRIKEOUT || a.object.type === PdfAnnotationSubtype.SQUIGGLY;
+}
+function isHighlight(a) {
+  return a.object.type === PdfAnnotationSubtype.HIGHLIGHT;
+}
+function isUnderline(a) {
+  return a.object.type === PdfAnnotationSubtype.UNDERLINE;
+}
+function isStrikeout(a) {
+  return a.object.type === PdfAnnotationSubtype.STRIKEOUT;
+}
+function isSquiggly(a) {
+  return a.object.type === PdfAnnotationSubtype.SQUIGGLY;
+}
+const AnnotationPluginPackage = {
   manifest,
   create: (registry, engine, config) => new AnnotationPlugin(ANNOTATION_PLUGIN_ID, registry, engine, config),
   reducer,
@@ -659,10 +988,26 @@ export {
   getAnnotationsByPageIndex,
   getSelectedAnnotation,
   getSelectedAnnotationByPageIndex,
-  getSelectedAnnotationMode,
+  getSelectedAnnotationVariant,
   getSelectedAnnotationWithPageIndex,
+  getToolDefaultsBySubtypeAndIntent,
   isAnnotationSelected,
-  isInAnnotationMode,
-  manifest
+  isCircle,
+  isHighlight,
+  isInAnnotationVariant,
+  isInk,
+  isLine,
+  isPolygon,
+  isPolyline,
+  isSquare,
+  isSquiggly,
+  isStrikeout,
+  isTextMarkup,
+  isUnderline,
+  makeVariantKey,
+  manifest,
+  parseVariantKey,
+  index as patching,
+  variantKeyFromAnnotation
 };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map