@pdfmergy-embedpdf/plugin-attachment 2.6.3

package/dist/index.js

@@ -0,0 +1,1571 @@
+const PdfSoftHyphenMarker$1 = "­";
+const PdfZeroWidthSpace$1 = "​";
+const PdfWordJoiner$1 = "⁠";
+const PdfBomOrZwnbsp$1 = "\uFEFF";
+const PdfNonCharacterFFFE$1 = "￾";
+const PdfNonCharacterFFFF$1 = "￿";
+const PdfUnwantedTextMarkers$1 = Object.freeze([
+  PdfSoftHyphenMarker$1,
+  PdfZeroWidthSpace$1,
+  PdfWordJoiner$1,
+  PdfBomOrZwnbsp$1,
+  PdfNonCharacterFFFE$1,
+  PdfNonCharacterFFFF$1
+]);
+new RegExp(`[${PdfUnwantedTextMarkers$1.join("")}]`, "g");
+var PdfStandardFont$1 = /* @__PURE__ */ ((PdfStandardFont2) => {
+  PdfStandardFont2[PdfStandardFont2["Unknown"] = -1] = "Unknown";
+  PdfStandardFont2[PdfStandardFont2["Courier"] = 0] = "Courier";
+  PdfStandardFont2[PdfStandardFont2["Courier_Bold"] = 1] = "Courier_Bold";
+  PdfStandardFont2[PdfStandardFont2["Courier_BoldOblique"] = 2] = "Courier_BoldOblique";
+  PdfStandardFont2[PdfStandardFont2["Courier_Oblique"] = 3] = "Courier_Oblique";
+  PdfStandardFont2[PdfStandardFont2["Helvetica"] = 4] = "Helvetica";
+  PdfStandardFont2[PdfStandardFont2["Helvetica_Bold"] = 5] = "Helvetica_Bold";
+  PdfStandardFont2[PdfStandardFont2["Helvetica_BoldOblique"] = 6] = "Helvetica_BoldOblique";
+  PdfStandardFont2[PdfStandardFont2["Helvetica_Oblique"] = 7] = "Helvetica_Oblique";
+  PdfStandardFont2[PdfStandardFont2["Times_Roman"] = 8] = "Times_Roman";
+  PdfStandardFont2[PdfStandardFont2["Times_Bold"] = 9] = "Times_Bold";
+  PdfStandardFont2[PdfStandardFont2["Times_BoldItalic"] = 10] = "Times_BoldItalic";
+  PdfStandardFont2[PdfStandardFont2["Times_Italic"] = 11] = "Times_Italic";
+  PdfStandardFont2[PdfStandardFont2["Symbol"] = 12] = "Symbol";
+  PdfStandardFont2[PdfStandardFont2["ZapfDingbats"] = 13] = "ZapfDingbats";
+  return PdfStandardFont2;
+})(PdfStandardFont$1 || {});
+var PdfTextAlignment$1 = /* @__PURE__ */ ((PdfTextAlignment2) => {
+  PdfTextAlignment2[PdfTextAlignment2["Left"] = 0] = "Left";
+  PdfTextAlignment2[PdfTextAlignment2["Center"] = 1] = "Center";
+  PdfTextAlignment2[PdfTextAlignment2["Right"] = 2] = "Right";
+  return PdfTextAlignment2;
+})(PdfTextAlignment$1 || {});
+var PdfBlendMode$1 = /* @__PURE__ */ ((PdfBlendMode2) => {
+  PdfBlendMode2[PdfBlendMode2["Normal"] = 0] = "Normal";
+  PdfBlendMode2[PdfBlendMode2["Multiply"] = 1] = "Multiply";
+  PdfBlendMode2[PdfBlendMode2["Screen"] = 2] = "Screen";
+  PdfBlendMode2[PdfBlendMode2["Overlay"] = 3] = "Overlay";
+  PdfBlendMode2[PdfBlendMode2["Darken"] = 4] = "Darken";
+  PdfBlendMode2[PdfBlendMode2["Lighten"] = 5] = "Lighten";
+  PdfBlendMode2[PdfBlendMode2["ColorDodge"] = 6] = "ColorDodge";
+  PdfBlendMode2[PdfBlendMode2["ColorBurn"] = 7] = "ColorBurn";
+  PdfBlendMode2[PdfBlendMode2["HardLight"] = 8] = "HardLight";
+  PdfBlendMode2[PdfBlendMode2["SoftLight"] = 9] = "SoftLight";
+  PdfBlendMode2[PdfBlendMode2["Difference"] = 10] = "Difference";
+  PdfBlendMode2[PdfBlendMode2["Exclusion"] = 11] = "Exclusion";
+  PdfBlendMode2[PdfBlendMode2["Hue"] = 12] = "Hue";
+  PdfBlendMode2[PdfBlendMode2["Saturation"] = 13] = "Saturation";
+  PdfBlendMode2[PdfBlendMode2["Color"] = 14] = "Color";
+  PdfBlendMode2[PdfBlendMode2["Luminosity"] = 15] = "Luminosity";
+  return PdfBlendMode2;
+})(PdfBlendMode$1 || {});
+const PdfAnnotationFlagName$1 = Object.freeze({
+  [
+    1
+    /* INVISIBLE */
+  ]: "invisible",
+  [
+    2
+    /* HIDDEN */
+  ]: "hidden",
+  [
+    4
+    /* PRINT */
+  ]: "print",
+  [
+    8
+    /* NO_ZOOM */
+  ]: "noZoom",
+  [
+    16
+    /* NO_ROTATE */
+  ]: "noRotate",
+  [
+    32
+    /* NO_VIEW */
+  ]: "noView",
+  [
+    64
+    /* READ_ONLY */
+  ]: "readOnly",
+  [
+    128
+    /* LOCKED */
+  ]: "locked",
+  [
+    256
+    /* TOGGLE_NOVIEW */
+  ]: "toggleNoView"
+});
+Object.entries(
+  PdfAnnotationFlagName$1
+).reduce(
+  (acc, [bit, name]) => {
+    acc[name] = Number(bit);
+    return acc;
+  },
+  {}
+);
+var PdfPermissionFlag = /* @__PURE__ */ ((PdfPermissionFlag2) => {
+  PdfPermissionFlag2[PdfPermissionFlag2["Print"] = 4] = "Print";
+  PdfPermissionFlag2[PdfPermissionFlag2["ModifyContents"] = 8] = "ModifyContents";
+  PdfPermissionFlag2[PdfPermissionFlag2["CopyContents"] = 16] = "CopyContents";
+  PdfPermissionFlag2[PdfPermissionFlag2["ModifyAnnotations"] = 32] = "ModifyAnnotations";
+  PdfPermissionFlag2[PdfPermissionFlag2["FillForms"] = 256] = "FillForms";
+  PdfPermissionFlag2[PdfPermissionFlag2["ExtractForAccessibility"] = 512] = "ExtractForAccessibility";
+  PdfPermissionFlag2[PdfPermissionFlag2["AssembleDocument"] = 1024] = "AssembleDocument";
+  PdfPermissionFlag2[PdfPermissionFlag2["PrintHighQuality"] = 2048] = "PrintHighQuality";
+  PdfPermissionFlag2[PdfPermissionFlag2["AllowAll"] = 3900] = "AllowAll";
+  return PdfPermissionFlag2;
+})(PdfPermissionFlag || {});
+class PermissionDeniedError extends Error {
+  constructor(requiredFlags, currentPermissions) {
+    const flagNames = requiredFlags.map((f) => PdfPermissionFlag[f]).join(", ");
+    super(`Permission denied. Required: ${flagNames}`);
+    this.requiredFlags = requiredFlags;
+    this.currentPermissions = currentPermissions;
+    this.name = "PermissionDeniedError";
+  }
+}
+const TEXT_ALIGNMENT_INFOS$1 = Object.freeze([
+  { id: PdfTextAlignment$1.Left, label: "Left", css: "left" },
+  { id: PdfTextAlignment$1.Center, label: "Center", css: "center" },
+  { id: PdfTextAlignment$1.Right, label: "Right", css: "right" }
+]);
+TEXT_ALIGNMENT_INFOS$1.reduce(
+  (m, info) => {
+    m[info.id] = info;
+    return m;
+  },
+  {}
+);
+TEXT_ALIGNMENT_INFOS$1.reduce(
+  (m, info) => {
+    m[info.css] = info.id;
+    return m;
+  },
+  {}
+);
+TEXT_ALIGNMENT_INFOS$1.map((info) => ({
+  value: info.id,
+  label: info.label
+}));
+var PdfStandardFontFamily$1 = /* @__PURE__ */ ((PdfStandardFontFamily2) => {
+  PdfStandardFontFamily2["Courier"] = "Courier";
+  PdfStandardFontFamily2["Helvetica"] = "Helvetica";
+  PdfStandardFontFamily2["Times"] = "Times";
+  PdfStandardFontFamily2["Symbol"] = "Symbol";
+  PdfStandardFontFamily2["ZapfDingbats"] = "ZapfDingbats";
+  PdfStandardFontFamily2["Unknown"] = "Unknown";
+  return PdfStandardFontFamily2;
+})(PdfStandardFontFamily$1 || {});
+PdfStandardFont$1.Helvetica;
+const HELVETICA_DESC$1 = {
+  id: PdfStandardFont$1.Helvetica,
+  family: "Helvetica",
+  bold: false,
+  italic: false,
+  label: "Helvetica",
+  css: "Helvetica, Arial, sans-serif"
+};
+const STANDARD_FONT_DESCRIPTORS$1 = Object.freeze([
+  {
+    id: PdfStandardFont$1.Courier,
+    family: "Courier",
+    bold: false,
+    italic: false,
+    label: "Courier",
+    css: "Courier, monospace"
+  },
+  {
+    id: PdfStandardFont$1.Courier_Bold,
+    family: "Courier",
+    bold: true,
+    italic: false,
+    label: "Courier Bold",
+    css: "Courier, monospace"
+  },
+  {
+    id: PdfStandardFont$1.Courier_BoldOblique,
+    family: "Courier",
+    bold: true,
+    italic: true,
+    label: "Courier Bold Oblique",
+    css: "Courier, monospace"
+  },
+  {
+    id: PdfStandardFont$1.Courier_Oblique,
+    family: "Courier",
+    bold: false,
+    italic: true,
+    label: "Courier Oblique",
+    css: "Courier, monospace"
+  },
+  HELVETICA_DESC$1,
+  {
+    id: PdfStandardFont$1.Helvetica_Bold,
+    family: "Helvetica",
+    bold: true,
+    italic: false,
+    label: "Helvetica Bold",
+    css: "Helvetica, Arial, sans-serif"
+  },
+  {
+    id: PdfStandardFont$1.Helvetica_BoldOblique,
+    family: "Helvetica",
+    bold: true,
+    italic: true,
+    label: "Helvetica Bold Oblique",
+    css: "Helvetica, Arial, sans-serif"
+  },
+  {
+    id: PdfStandardFont$1.Helvetica_Oblique,
+    family: "Helvetica",
+    bold: false,
+    italic: true,
+    label: "Helvetica Oblique",
+    css: "Helvetica, Arial, sans-serif"
+  },
+  {
+    id: PdfStandardFont$1.Times_Roman,
+    family: "Times",
+    bold: false,
+    italic: false,
+    label: "Times Roman",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont$1.Times_Bold,
+    family: "Times",
+    bold: true,
+    italic: false,
+    label: "Times Bold",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont$1.Times_BoldItalic,
+    family: "Times",
+    bold: true,
+    italic: true,
+    label: "Times Bold Italic",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont$1.Times_Italic,
+    family: "Times",
+    bold: false,
+    italic: true,
+    label: "Times Italic",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont$1.Symbol,
+    family: "Symbol",
+    bold: false,
+    italic: false,
+    label: "Symbol",
+    css: "Symbol, serif"
+  },
+  {
+    id: PdfStandardFont$1.ZapfDingbats,
+    family: "ZapfDingbats",
+    bold: false,
+    italic: false,
+    label: "Zapf Dingbats",
+    css: "ZapfDingbats, serif"
+  }
+]);
+STANDARD_FONT_DESCRIPTORS$1.reduce((m, d) => (m[d.id] = d, m), {});
+const familyStyleToId$1 = /* @__PURE__ */ new Map();
+for (const d of STANDARD_FONT_DESCRIPTORS$1) {
+  familyStyleToId$1.set(`${d.family}_${d.bold}_${d.italic}`, d.id);
+}
+Object.values(PdfStandardFontFamily$1).filter(
+  (f) => f !== "Unknown"
+  /* Unknown */
+).map((family) => ({ value: family, label: family }));
+[
+  ...new Set(STANDARD_FONT_DESCRIPTORS$1.map((d) => d.family))
+];
+const BLEND_MODE_INFOS$1 = Object.freeze([
+  { id: PdfBlendMode$1.Normal, label: "Normal", css: "normal" },
+  { id: PdfBlendMode$1.Multiply, label: "Multiply", css: "multiply" },
+  { id: PdfBlendMode$1.Screen, label: "Screen", css: "screen" },
+  { id: PdfBlendMode$1.Overlay, label: "Overlay", css: "overlay" },
+  { id: PdfBlendMode$1.Darken, label: "Darken", css: "darken" },
+  { id: PdfBlendMode$1.Lighten, label: "Lighten", css: "lighten" },
+  { id: PdfBlendMode$1.ColorDodge, label: "Color Dodge", css: "color-dodge" },
+  { id: PdfBlendMode$1.ColorBurn, label: "Color Burn", css: "color-burn" },
+  { id: PdfBlendMode$1.HardLight, label: "Hard Light", css: "hard-light" },
+  { id: PdfBlendMode$1.SoftLight, label: "Soft Light", css: "soft-light" },
+  { id: PdfBlendMode$1.Difference, label: "Difference", css: "difference" },
+  { id: PdfBlendMode$1.Exclusion, label: "Exclusion", css: "exclusion" },
+  { id: PdfBlendMode$1.Hue, label: "Hue", css: "hue" },
+  { id: PdfBlendMode$1.Saturation, label: "Saturation", css: "saturation" },
+  { id: PdfBlendMode$1.Color, label: "Color", css: "color" },
+  { id: PdfBlendMode$1.Luminosity, label: "Luminosity", css: "luminosity" }
+]);
+BLEND_MODE_INFOS$1.reduce(
+  (m, info) => {
+    m[info.id] = info;
+    return m;
+  },
+  {}
+);
+BLEND_MODE_INFOS$1.reduce(
+  (m, info) => {
+    m[info.css] = info.id;
+    return m;
+  },
+  {}
+);
+BLEND_MODE_INFOS$1.map((info) => ({
+  value: info.id,
+  label: info.label
+}));
+BLEND_MODE_INFOS$1.map((info) => info.id);
+const START_LOADING_DOCUMENT = "START_LOADING_DOCUMENT";
+const SET_DOCUMENT_LOADED = "SET_DOCUMENT_LOADED";
+const CLOSE_DOCUMENT = "CLOSE_DOCUMENT";
+const SET_SCALE = "SET_SCALE";
+const SET_ROTATION = "SET_ROTATION";
+({
+  print: PdfPermissionFlag.Print,
+  modifyContents: PdfPermissionFlag.ModifyContents,
+  copyContents: PdfPermissionFlag.CopyContents,
+  modifyAnnotations: PdfPermissionFlag.ModifyAnnotations,
+  fillForms: PdfPermissionFlag.FillForms,
+  extractForAccessibility: PdfPermissionFlag.ExtractForAccessibility,
+  assembleDocument: PdfPermissionFlag.AssembleDocument,
+  printHighQuality: PdfPermissionFlag.PrintHighQuality
+});
+const ALL_PERMISSION_FLAGS = [
+  PdfPermissionFlag.Print,
+  PdfPermissionFlag.ModifyContents,
+  PdfPermissionFlag.CopyContents,
+  PdfPermissionFlag.ModifyAnnotations,
+  PdfPermissionFlag.FillForms,
+  PdfPermissionFlag.ExtractForAccessibility,
+  PdfPermissionFlag.AssembleDocument,
+  PdfPermissionFlag.PrintHighQuality
+];
+const PERMISSION_FLAG_TO_NAME = {
+  [PdfPermissionFlag.Print]: "print",
+  [PdfPermissionFlag.ModifyContents]: "modifyContents",
+  [PdfPermissionFlag.CopyContents]: "copyContents",
+  [PdfPermissionFlag.ModifyAnnotations]: "modifyAnnotations",
+  [PdfPermissionFlag.FillForms]: "fillForms",
+  [PdfPermissionFlag.ExtractForAccessibility]: "extractForAccessibility",
+  [PdfPermissionFlag.AssembleDocument]: "assembleDocument",
+  [PdfPermissionFlag.PrintHighQuality]: "printHighQuality"
+};
+function getPermissionOverride(overrides, flag) {
+  if (!overrides) return void 0;
+  if (flag in overrides) {
+    return overrides[flag];
+  }
+  const name = PERMISSION_FLAG_TO_NAME[flag];
+  if (name && name in overrides) {
+    return overrides[name];
+  }
+  return void 0;
+}
+function getEffectivePermission(state, documentId, flag) {
+  var _a;
+  const docState = state.documents[documentId];
+  const docConfig = docState == null ? void 0 : docState.permissions;
+  const globalConfig = state.globalPermissions;
+  const pdfPermissions = ((_a = docState == null ? void 0 : docState.document) == null ? void 0 : _a.permissions) ?? PdfPermissionFlag.AllowAll;
+  const docOverride = getPermissionOverride(docConfig == null ? void 0 : docConfig.overrides, flag);
+  if (docOverride !== void 0) {
+    return docOverride;
+  }
+  const globalOverride = getPermissionOverride(globalConfig == null ? void 0 : globalConfig.overrides, flag);
+  if (globalOverride !== void 0) {
+    return globalOverride;
+  }
+  const enforce = (docConfig == null ? void 0 : docConfig.enforceDocumentPermissions) ?? (globalConfig == null ? void 0 : globalConfig.enforceDocumentPermissions) ?? true;
+  if (!enforce) return true;
+  return (pdfPermissions & flag) !== 0;
+}
+function getEffectivePermissions(state, documentId) {
+  return ALL_PERMISSION_FLAGS.reduce((acc, flag) => {
+    return getEffectivePermission(state, documentId, flag) ? acc | flag : acc;
+  }, 0);
+}
+class BasePlugin {
+  constructor(id, registry) {
+    this.id = id;
+    this.registry = registry;
+    this.cooldownActions = {};
+    this.debouncedTimeouts = {};
+    this.unsubscribeFromState = null;
+    this.unsubscribeFromCoreStore = null;
+    this.unsubscribeFromStartLoadingDocument = null;
+    this.unsubscribeFromSetDocumentLoaded = null;
+    this.unsubscribeFromCloseDocument = null;
+    this.unsubscribeFromSetScale = null;
+    this.unsubscribeFromSetRotation = null;
+    if (id !== this.constructor.id) {
+      throw new Error(
+        `Plugin ID mismatch: ${id} !== ${this.constructor.id}`
+      );
+    }
+    this.engine = this.registry.getEngine();
+    this.logger = this.registry.getLogger();
+    this.coreStore = this.registry.getStore();
+    this.pluginStore = this.coreStore.getPluginStore(this.id);
+    this.unsubscribeFromState = this.pluginStore.subscribeToState((action, newState, oldState) => {
+      this.onStoreUpdated(oldState, newState);
+    });
+    this.unsubscribeFromCoreStore = this.coreStore.subscribe((action, newState, oldState) => {
+      this.onCoreStoreUpdated(oldState, newState);
+      if (newState.core.activeDocumentId !== oldState.core.activeDocumentId) {
+        this.onActiveDocumentChanged(
+          oldState.core.activeDocumentId,
+          newState.core.activeDocumentId
+        );
+      }
+    });
+    this.unsubscribeFromStartLoadingDocument = this.coreStore.onAction(
+      START_LOADING_DOCUMENT,
+      (action) => {
+        this.onDocumentLoadingStarted(action.payload.documentId);
+      }
+    );
+    this.unsubscribeFromSetDocumentLoaded = this.coreStore.onAction(
+      SET_DOCUMENT_LOADED,
+      (action) => {
+        this.onDocumentLoaded(action.payload.documentId);
+      }
+    );
+    this.unsubscribeFromCloseDocument = this.coreStore.onAction(CLOSE_DOCUMENT, (action) => {
+      this.onDocumentClosed(action.payload.documentId);
+    });
+    this.unsubscribeFromSetScale = this.coreStore.onAction(SET_SCALE, (action, state) => {
+      const targetId = action.payload.documentId ?? state.core.activeDocumentId;
+      if (targetId) {
+        this.onScaleChanged(targetId, action.payload.scale);
+      }
+    });
+    this.unsubscribeFromSetRotation = this.coreStore.onAction(SET_ROTATION, (action, state) => {
+      const targetId = action.payload.documentId ?? state.core.activeDocumentId;
+      if (targetId) {
+        this.onRotationChanged(targetId, action.payload.rotation);
+      }
+    });
+    this.readyPromise = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+    this.readyResolve();
+  }
+  provides() {
+    if (!this._capability) {
+      const cap = this.buildCapability();
+      this._capability = Object.freeze(cap);
+    }
+    return this._capability;
+  }
+  /**
+   *  Get a copy of the current state
+   */
+  get state() {
+    return this.pluginStore.getState();
+  }
+  /**
+   *  Get a copy of the current core state
+   */
+  get coreState() {
+    return this.coreStore.getState();
+  }
+  /**
+   * @deprecated  use `this.state` Get a copy of the current state
+   */
+  getState() {
+    return this.pluginStore.getState();
+  }
+  /**
+   * @deprecated  use `this.coreState` Get a copy of the current core state
+   */
+  getCoreState() {
+    return this.coreStore.getState();
+  }
+  /**
+   * Core Dispatch
+   */
+  dispatchCoreAction(action) {
+    return this.coreStore.dispatchToCore(action);
+  }
+  /**
+   * Dispatch an action to all plugins
+   */
+  dispatchToAllPlugins(action) {
+    return this.coreStore.dispatch(action);
+  }
+  /**
+   * Dispatch an action
+   */
+  dispatch(action) {
+    return this.pluginStore.dispatch(action);
+  }
+  /**
+   * Dispatch an action with a cooldown to prevent rapid repeated calls
+   * This executes immediately if cooldown has expired, then blocks subsequent calls
+   * @param action The action to dispatch
+   * @param cooldownTime Time in ms for cooldown (default: 100ms)
+   * @returns boolean indicating whether the action was dispatched or blocked
+   */
+  cooldownDispatch(action, cooldownTime = 100) {
+    const now = Date.now();
+    const lastActionTime = this.cooldownActions[action.type] || 0;
+    if (now - lastActionTime >= cooldownTime) {
+      this.cooldownActions[action.type] = now;
+      this.dispatch(action);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Dispatch an action with true debouncing - waits for the delay after the last call
+   * Each new call resets the timer. Action only executes after no calls for the specified time.
+   * @param action The action to dispatch
+   * @param debounceTime Time in ms to wait after the last call
+   */
+  debouncedDispatch(action, debounceTime = 100) {
+    const actionKey = action.type;
+    if (this.debouncedTimeouts[actionKey]) {
+      clearTimeout(this.debouncedTimeouts[actionKey]);
+    }
+    this.debouncedTimeouts[actionKey] = setTimeout(() => {
+      this.dispatch(action);
+      delete this.debouncedTimeouts[actionKey];
+    }, debounceTime);
+  }
+  /**
+   * Cancel a pending debounced action
+   * @param actionType The action type to cancel
+   */
+  cancelDebouncedDispatch(actionType) {
+    if (this.debouncedTimeouts[actionType]) {
+      clearTimeout(this.debouncedTimeouts[actionType]);
+      delete this.debouncedTimeouts[actionType];
+    }
+  }
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(listener) {
+    return this.pluginStore.subscribeToState(listener);
+  }
+  /**
+   * Subscribe to core store changes
+   */
+  subscribeToCoreStore(listener) {
+    return this.coreStore.subscribe(listener);
+  }
+  /**
+   * Called when the plugin store state is updated
+   * @param oldState Previous state
+   * @param newState New state
+   */
+  onStoreUpdated(oldState, newState) {
+  }
+  /**
+   * Called when the core store state is updated
+   * @param oldState Previous state
+   * @param newState New state
+   */
+  onCoreStoreUpdated(oldState, newState) {
+  }
+  /**
+   * Called when a document is opened
+   * Override to initialize per-document state
+   * @param documentId The ID of the document that was opened
+   */
+  onDocumentLoadingStarted(documentId) {
+  }
+  /**
+   * Called when a document is loaded
+   * @param documentId The ID of the document that is loaded
+   */
+  onDocumentLoaded(documentId) {
+  }
+  /**
+   * Called when a document is closed
+   * Override to cleanup per-document state
+   * @param documentId The ID of the document that was closed
+   */
+  onDocumentClosed(documentId) {
+  }
+  /**
+   * Called when the active document changes
+   * @param previousId The ID of the previous active document
+   * @param currentId The ID of the new active document
+   */
+  onActiveDocumentChanged(previousId, currentId) {
+  }
+  onScaleChanged(documentId, scale) {
+  }
+  onRotationChanged(documentId, rotation) {
+  }
+  /**
+   * Cleanup method to be called when plugin is being destroyed
+   */
+  destroy() {
+    Object.values(this.debouncedTimeouts).forEach((timeout) => {
+      clearTimeout(timeout);
+    });
+    this.debouncedTimeouts = {};
+    if (this.unsubscribeFromState) {
+      this.unsubscribeFromState();
+      this.unsubscribeFromState = null;
+    }
+    if (this.unsubscribeFromCoreStore) {
+      this.unsubscribeFromCoreStore();
+      this.unsubscribeFromCoreStore = null;
+    }
+    if (this.unsubscribeFromStartLoadingDocument) {
+      this.unsubscribeFromStartLoadingDocument();
+      this.unsubscribeFromStartLoadingDocument = null;
+    }
+    if (this.unsubscribeFromSetDocumentLoaded) {
+      this.unsubscribeFromSetDocumentLoaded();
+      this.unsubscribeFromSetDocumentLoaded = null;
+    }
+    if (this.unsubscribeFromCloseDocument) {
+      this.unsubscribeFromCloseDocument();
+      this.unsubscribeFromCloseDocument = null;
+    }
+    if (this.unsubscribeFromSetScale) {
+      this.unsubscribeFromSetScale();
+      this.unsubscribeFromSetScale = null;
+    }
+    if (this.unsubscribeFromSetRotation) {
+      this.unsubscribeFromSetRotation();
+      this.unsubscribeFromSetRotation = null;
+    }
+  }
+  /**
+   * Returns a promise that resolves when the plugin is ready
+   */
+  ready() {
+    return this.readyPromise;
+  }
+  /**
+   * Mark the plugin as ready
+   */
+  markReady() {
+    this.readyResolve();
+  }
+  /**
+   * Reset the ready state (useful for plugins that need to reinitialize)
+   */
+  resetReady() {
+    this.readyPromise = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+  }
+  /**
+   * Get the active document ID
+   * @throws Error if no active document exists
+   */
+  getActiveDocumentId() {
+    const id = this.coreState.core.activeDocumentId;
+    if (!id) {
+      throw new Error("No active document");
+    }
+    return id;
+  }
+  /**
+   * Get the active document ID or null if none exists
+   */
+  getActiveDocumentIdOrNull() {
+    return this.coreState.core.activeDocumentId;
+  }
+  /**
+   * Get core document state for a specific document
+   * @param documentId Document ID (optional, defaults to active document)
+   * @returns Document state or null if not found
+   */
+  getCoreDocument(documentId) {
+    const id = documentId ?? this.getActiveDocumentIdOrNull();
+    if (!id) return null;
+    return this.coreState.core.documents[id] ?? null;
+  }
+  /**
+   * Get core document state for a specific document
+   * @param documentId Document ID (optional, defaults to active document)
+   * @throws Error if document not found
+   */
+  getCoreDocumentOrThrow(documentId) {
+    const doc = this.getCoreDocument(documentId);
+    if (!doc) {
+      throw new Error(`Document not found: ${documentId ?? "active"}`);
+    }
+    return doc;
+  }
+  // ─────────────────────────────────────────────────────────
+  // Permission Helpers
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Get the effective permission flags for a document.
+   * Applies layered resolution: per-document override → global override → PDF permission.
+   * Returns AllowAll if document not found.
+   * @param documentId Document ID (optional, defaults to active document)
+   */
+  getDocumentPermissions(documentId) {
+    const docId = documentId ?? this.coreState.core.activeDocumentId;
+    if (!docId) return PdfPermissionFlag.AllowAll;
+    return getEffectivePermissions(this.coreState.core, docId);
+  }
+  /**
+   * Check if a document has the required permissions (returns boolean).
+   * Applies layered resolution: per-document override → global override → PDF permission.
+   * Useful for conditional UI logic.
+   * @param documentId Document ID (optional, defaults to active document)
+   * @param flags Permission flags to check
+   */
+  checkPermission(documentId, ...flags) {
+    const docId = documentId ?? this.coreState.core.activeDocumentId;
+    if (!docId) return true;
+    return flags.every((flag) => getEffectivePermission(this.coreState.core, docId, flag));
+  }
+  /**
+   * Assert that a document has the required permissions.
+   * Applies layered resolution: per-document override → global override → PDF permission.
+   * Throws PermissionDeniedError if any flag is missing.
+   * @param documentId Document ID (optional, defaults to active document)
+   * @param flags Permission flags to require
+   */
+  requirePermission(documentId, ...flags) {
+    const docId = documentId ?? this.coreState.core.activeDocumentId;
+    if (!docId) return;
+    const missingFlags = [];
+    for (const flag of flags) {
+      if (!getEffectivePermission(this.coreState.core, docId, flag)) {
+        missingFlags.push(flag);
+      }
+    }
+    if (missingFlags.length > 0) {
+      const effectivePermissions = getEffectivePermissions(this.coreState.core, docId);
+      throw new PermissionDeniedError(missingFlags, effectivePermissions);
+    }
+  }
+}
+class TaskAbortedError extends Error {
+  constructor(reason) {
+    super(`Task aborted: ${JSON.stringify(reason)}`);
+    this.name = "TaskAbortedError";
+    this.reason = reason;
+  }
+}
+class TaskRejectedError extends Error {
+  constructor(reason) {
+    super(`Task rejected: ${JSON.stringify(reason)}`);
+    this.name = "TaskRejectedError";
+    this.reason = reason;
+  }
+}
+class Task {
+  constructor() {
+    this.state = {
+      stage: 0
+      /* Pending */
+    };
+    this.resolvedCallbacks = [];
+    this.rejectedCallbacks = [];
+    this._promise = null;
+    this.progressCbs = [];
+  }
+  /**
+   * Convert task to promise
+   * @returns promise that will be resolved when task is settled
+   */
+  toPromise() {
+    if (!this._promise) {
+      this._promise = new Promise((resolve, reject) => {
+        this.wait(
+          (result) => resolve(result),
+          (error) => {
+            if (error.type === "abort") {
+              reject(new TaskAbortedError(error.reason));
+            } else {
+              reject(new TaskRejectedError(error.reason));
+            }
+          }
+        );
+      });
+    }
+    return this._promise;
+  }
+  /**
+   * wait for task to be settled
+   * @param resolvedCallback - callback for resolved value
+   * @param rejectedCallback - callback for rejected value
+   */
+  wait(resolvedCallback, rejectedCallback) {
+    switch (this.state.stage) {
+      case 0:
+        this.resolvedCallbacks.push(resolvedCallback);
+        this.rejectedCallbacks.push(rejectedCallback);
+        break;
+      case 1:
+        resolvedCallback(this.state.result);
+        break;
+      case 2:
+        rejectedCallback({
+          type: "reject",
+          reason: this.state.reason
+        });
+        break;
+      case 3:
+        rejectedCallback({
+          type: "abort",
+          reason: this.state.reason
+        });
+        break;
+    }
+  }
+  /**
+   * resolve task with specific result
+   * @param result - result value
+   */
+  resolve(result) {
+    if (this.state.stage === 0) {
+      this.state = {
+        stage: 1,
+        result
+      };
+      for (const resolvedCallback of this.resolvedCallbacks) {
+        try {
+          resolvedCallback(result);
+        } catch (e) {
+        }
+      }
+      this.resolvedCallbacks = [];
+      this.rejectedCallbacks = [];
+    }
+  }
+  /**
+   * reject task with specific reason
+   * @param reason - abort reason
+   *
+   */
+  reject(reason) {
+    if (this.state.stage === 0) {
+      this.state = {
+        stage: 2,
+        reason
+      };
+      for (const rejectedCallback of this.rejectedCallbacks) {
+        try {
+          rejectedCallback({
+            type: "reject",
+            reason
+          });
+        } catch (e) {
+        }
+      }
+      this.resolvedCallbacks = [];
+      this.rejectedCallbacks = [];
+    }
+  }
+  /**
+   * abort task with specific reason
+   * @param reason - abort reason
+   */
+  abort(reason) {
+    if (this.state.stage === 0) {
+      this.state = {
+        stage: 3,
+        reason
+      };
+      for (const rejectedCallback of this.rejectedCallbacks) {
+        try {
+          rejectedCallback({
+            type: "abort",
+            reason
+          });
+        } catch (e) {
+        }
+      }
+      this.resolvedCallbacks = [];
+      this.rejectedCallbacks = [];
+    }
+  }
+  /**
+   * fail task with a TaskError from another task
+   * This is a convenience method for error propagation between tasks
+   * @param error - TaskError from another task
+   */
+  fail(error) {
+    if (error.type === "abort") {
+      this.abort(error.reason);
+    } else {
+      this.reject(error.reason);
+    }
+  }
+  /**
+   * Transform the result of this task using a mapping function.
+   * Returns a new Task that resolves with the mapped value.
+   *
+   * Aborting the derived task also aborts the source task, and source errors
+   * are forwarded to the derived task directly (bypassing `errMap`).
+   *
+   * Note: progress events from the source task are **not** forwarded
+   * to the derived task.
+   *
+   * @param fn - mapping function that transforms the source result
+   * @param errMap - maps errors from `fn` (sync throws or rejected promises)
+   *   into the error type `D`. Source task errors are forwarded as-is.
+   * @returns a new Task that resolves with the mapped result
+   */
+  map(fn, errMap) {
+    const derived = new Task();
+    const origAbort = derived.abort.bind(derived);
+    derived.abort = (reason) => {
+      this.abort(reason);
+      origAbort(reason);
+    };
+    this.wait(
+      (result) => {
+        if (derived.state.stage !== 0) return;
+        try {
+          const mapped = fn(result);
+          if (mapped instanceof Promise) {
+            mapped.then(
+              (value) => {
+                if (derived.state.stage === 0) {
+                  derived.resolve(value);
+                }
+              },
+              (err) => {
+                if (derived.state.stage === 0) {
+                  derived.reject(errMap(err));
+                }
+              }
+            );
+          } else {
+            derived.resolve(mapped);
+          }
+        } catch (err) {
+          if (derived.state.stage === 0) {
+            derived.reject(errMap(err));
+          }
+        }
+      },
+      (error) => {
+        if (derived.state.stage === 0) {
+          derived.fail(error);
+        }
+      }
+    );
+    return derived;
+  }
+  /**
+   * add a progress callback
+   * @param cb - progress callback
+   */
+  onProgress(cb) {
+    this.progressCbs.push(cb);
+  }
+  /**
+   * call progress callback
+   * @param p - progress value
+   */
+  progress(p) {
+    for (const cb of this.progressCbs) cb(p);
+  }
+  /**
+   * Static method to wait for all tasks to resolve
+   * Returns a new task that resolves with an array of all results
+   * Rejects immediately if any task fails
+   *
+   * @param tasks - array of tasks to wait for
+   * @returns new task that resolves when all input tasks resolve
+   * @public
+   */
+  static all(tasks) {
+    const combinedTask = new Task();
+    if (tasks.length === 0) {
+      combinedTask.resolve([]);
+      return combinedTask;
+    }
+    const results = new Array(tasks.length);
+    let resolvedCount = 0;
+    let isSettled = false;
+    tasks.forEach((task, index) => {
+      task.wait(
+        (result) => {
+          if (isSettled) return;
+          results[index] = result;
+          resolvedCount++;
+          if (resolvedCount === tasks.length) {
+            isSettled = true;
+            combinedTask.resolve(results);
+          }
+        },
+        (error) => {
+          if (isSettled) return;
+          isSettled = true;
+          if (error.type === "abort") {
+            combinedTask.abort(error.reason);
+          } else {
+            combinedTask.reject(error.reason);
+          }
+        }
+      );
+    });
+    return combinedTask;
+  }
+  /**
+   * Static method to wait for all tasks to settle (resolve, reject, or abort)
+   * Always resolves with an array of settlement results
+   *
+   * @param tasks - array of tasks to wait for
+   * @returns new task that resolves when all input tasks settle
+   * @public
+   */
+  static allSettled(tasks) {
+    const combinedTask = new Task();
+    if (tasks.length === 0) {
+      combinedTask.resolve([]);
+      return combinedTask;
+    }
+    const results = new Array(tasks.length);
+    let settledCount = 0;
+    tasks.forEach((task, index) => {
+      task.wait(
+        (result) => {
+          results[index] = { status: "resolved", value: result };
+          settledCount++;
+          if (settledCount === tasks.length) {
+            combinedTask.resolve(results);
+          }
+        },
+        (error) => {
+          results[index] = {
+            status: error.type === "abort" ? "aborted" : "rejected",
+            reason: error.reason
+          };
+          settledCount++;
+          if (settledCount === tasks.length) {
+            combinedTask.resolve(results);
+          }
+        }
+      );
+    });
+    return combinedTask;
+  }
+  /**
+   * Static method that resolves/rejects with the first task that settles
+   *
+   * @param tasks - array of tasks to race
+   * @returns new task that settles with the first input task that settles
+   * @public
+   */
+  static race(tasks) {
+    const combinedTask = new Task();
+    if (tasks.length === 0) {
+      combinedTask.reject("No tasks provided");
+      return combinedTask;
+    }
+    let isSettled = false;
+    tasks.forEach((task) => {
+      task.wait(
+        (result) => {
+          if (isSettled) return;
+          isSettled = true;
+          combinedTask.resolve(result);
+        },
+        (error) => {
+          if (isSettled) return;
+          isSettled = true;
+          if (error.type === "abort") {
+            combinedTask.abort(error.reason);
+          } else {
+            combinedTask.reject(error.reason);
+          }
+        }
+      );
+    });
+    return combinedTask;
+  }
+  /**
+   * Utility to track progress of multiple tasks
+   *
+   * @param tasks - array of tasks to track
+   * @param onProgress - callback called when any task completes
+   * @returns new task that resolves when all input tasks resolve
+   * @public
+   */
+  static withProgress(tasks, onProgress) {
+    const combinedTask = Task.all(tasks);
+    if (onProgress) {
+      let completedCount = 0;
+      tasks.forEach((task) => {
+        task.wait(
+          () => {
+            completedCount++;
+            onProgress(completedCount, tasks.length);
+          },
+          () => {
+            completedCount++;
+            onProgress(completedCount, tasks.length);
+          }
+        );
+      });
+    }
+    return combinedTask;
+  }
+}
+const PdfSoftHyphenMarker = "­";
+const PdfZeroWidthSpace = "​";
+const PdfWordJoiner = "⁠";
+const PdfBomOrZwnbsp = "\uFEFF";
+const PdfNonCharacterFFFE = "￾";
+const PdfNonCharacterFFFF = "￿";
+const PdfUnwantedTextMarkers = Object.freeze([
+  PdfSoftHyphenMarker,
+  PdfZeroWidthSpace,
+  PdfWordJoiner,
+  PdfBomOrZwnbsp,
+  PdfNonCharacterFFFE,
+  PdfNonCharacterFFFF
+]);
+new RegExp(`[${PdfUnwantedTextMarkers.join("")}]`, "g");
+var PdfStandardFont = /* @__PURE__ */ ((PdfStandardFont2) => {
+  PdfStandardFont2[PdfStandardFont2["Unknown"] = -1] = "Unknown";
+  PdfStandardFont2[PdfStandardFont2["Courier"] = 0] = "Courier";
+  PdfStandardFont2[PdfStandardFont2["Courier_Bold"] = 1] = "Courier_Bold";
+  PdfStandardFont2[PdfStandardFont2["Courier_BoldOblique"] = 2] = "Courier_BoldOblique";
+  PdfStandardFont2[PdfStandardFont2["Courier_Oblique"] = 3] = "Courier_Oblique";
+  PdfStandardFont2[PdfStandardFont2["Helvetica"] = 4] = "Helvetica";
+  PdfStandardFont2[PdfStandardFont2["Helvetica_Bold"] = 5] = "Helvetica_Bold";
+  PdfStandardFont2[PdfStandardFont2["Helvetica_BoldOblique"] = 6] = "Helvetica_BoldOblique";
+  PdfStandardFont2[PdfStandardFont2["Helvetica_Oblique"] = 7] = "Helvetica_Oblique";
+  PdfStandardFont2[PdfStandardFont2["Times_Roman"] = 8] = "Times_Roman";
+  PdfStandardFont2[PdfStandardFont2["Times_Bold"] = 9] = "Times_Bold";
+  PdfStandardFont2[PdfStandardFont2["Times_BoldItalic"] = 10] = "Times_BoldItalic";
+  PdfStandardFont2[PdfStandardFont2["Times_Italic"] = 11] = "Times_Italic";
+  PdfStandardFont2[PdfStandardFont2["Symbol"] = 12] = "Symbol";
+  PdfStandardFont2[PdfStandardFont2["ZapfDingbats"] = 13] = "ZapfDingbats";
+  return PdfStandardFont2;
+})(PdfStandardFont || {});
+var PdfTextAlignment = /* @__PURE__ */ ((PdfTextAlignment2) => {
+  PdfTextAlignment2[PdfTextAlignment2["Left"] = 0] = "Left";
+  PdfTextAlignment2[PdfTextAlignment2["Center"] = 1] = "Center";
+  PdfTextAlignment2[PdfTextAlignment2["Right"] = 2] = "Right";
+  return PdfTextAlignment2;
+})(PdfTextAlignment || {});
+var PdfBlendMode = /* @__PURE__ */ ((PdfBlendMode2) => {
+  PdfBlendMode2[PdfBlendMode2["Normal"] = 0] = "Normal";
+  PdfBlendMode2[PdfBlendMode2["Multiply"] = 1] = "Multiply";
+  PdfBlendMode2[PdfBlendMode2["Screen"] = 2] = "Screen";
+  PdfBlendMode2[PdfBlendMode2["Overlay"] = 3] = "Overlay";
+  PdfBlendMode2[PdfBlendMode2["Darken"] = 4] = "Darken";
+  PdfBlendMode2[PdfBlendMode2["Lighten"] = 5] = "Lighten";
+  PdfBlendMode2[PdfBlendMode2["ColorDodge"] = 6] = "ColorDodge";
+  PdfBlendMode2[PdfBlendMode2["ColorBurn"] = 7] = "ColorBurn";
+  PdfBlendMode2[PdfBlendMode2["HardLight"] = 8] = "HardLight";
+  PdfBlendMode2[PdfBlendMode2["SoftLight"] = 9] = "SoftLight";
+  PdfBlendMode2[PdfBlendMode2["Difference"] = 10] = "Difference";
+  PdfBlendMode2[PdfBlendMode2["Exclusion"] = 11] = "Exclusion";
+  PdfBlendMode2[PdfBlendMode2["Hue"] = 12] = "Hue";
+  PdfBlendMode2[PdfBlendMode2["Saturation"] = 13] = "Saturation";
+  PdfBlendMode2[PdfBlendMode2["Color"] = 14] = "Color";
+  PdfBlendMode2[PdfBlendMode2["Luminosity"] = 15] = "Luminosity";
+  return PdfBlendMode2;
+})(PdfBlendMode || {});
+const PdfAnnotationFlagName = Object.freeze({
+  [
+    1
+    /* INVISIBLE */
+  ]: "invisible",
+  [
+    2
+    /* HIDDEN */
+  ]: "hidden",
+  [
+    4
+    /* PRINT */
+  ]: "print",
+  [
+    8
+    /* NO_ZOOM */
+  ]: "noZoom",
+  [
+    16
+    /* NO_ROTATE */
+  ]: "noRotate",
+  [
+    32
+    /* NO_VIEW */
+  ]: "noView",
+  [
+    64
+    /* READ_ONLY */
+  ]: "readOnly",
+  [
+    128
+    /* LOCKED */
+  ]: "locked",
+  [
+    256
+    /* TOGGLE_NOVIEW */
+  ]: "toggleNoView"
+});
+Object.entries(
+  PdfAnnotationFlagName
+).reduce(
+  (acc, [bit, name]) => {
+    acc[name] = Number(bit);
+    return acc;
+  },
+  {}
+);
+var PdfErrorCode = /* @__PURE__ */ ((PdfErrorCode2) => {
+  PdfErrorCode2[PdfErrorCode2["Ok"] = 0] = "Ok";
+  PdfErrorCode2[PdfErrorCode2["Unknown"] = 1] = "Unknown";
+  PdfErrorCode2[PdfErrorCode2["NotFound"] = 2] = "NotFound";
+  PdfErrorCode2[PdfErrorCode2["WrongFormat"] = 3] = "WrongFormat";
+  PdfErrorCode2[PdfErrorCode2["Password"] = 4] = "Password";
+  PdfErrorCode2[PdfErrorCode2["Security"] = 5] = "Security";
+  PdfErrorCode2[PdfErrorCode2["PageError"] = 6] = "PageError";
+  PdfErrorCode2[PdfErrorCode2["XFALoad"] = 7] = "XFALoad";
+  PdfErrorCode2[PdfErrorCode2["XFALayout"] = 8] = "XFALayout";
+  PdfErrorCode2[PdfErrorCode2["Cancelled"] = 9] = "Cancelled";
+  PdfErrorCode2[PdfErrorCode2["Initialization"] = 10] = "Initialization";
+  PdfErrorCode2[PdfErrorCode2["NotReady"] = 11] = "NotReady";
+  PdfErrorCode2[PdfErrorCode2["NotSupport"] = 12] = "NotSupport";
+  PdfErrorCode2[PdfErrorCode2["LoadDoc"] = 13] = "LoadDoc";
+  PdfErrorCode2[PdfErrorCode2["DocNotOpen"] = 14] = "DocNotOpen";
+  PdfErrorCode2[PdfErrorCode2["CantCloseDoc"] = 15] = "CantCloseDoc";
+  PdfErrorCode2[PdfErrorCode2["CantCreateNewDoc"] = 16] = "CantCreateNewDoc";
+  PdfErrorCode2[PdfErrorCode2["CantImportPages"] = 17] = "CantImportPages";
+  PdfErrorCode2[PdfErrorCode2["CantCreateAnnot"] = 18] = "CantCreateAnnot";
+  PdfErrorCode2[PdfErrorCode2["CantSetAnnotRect"] = 19] = "CantSetAnnotRect";
+  PdfErrorCode2[PdfErrorCode2["CantSetAnnotContent"] = 20] = "CantSetAnnotContent";
+  PdfErrorCode2[PdfErrorCode2["CantRemoveInkList"] = 21] = "CantRemoveInkList";
+  PdfErrorCode2[PdfErrorCode2["CantAddInkStoke"] = 22] = "CantAddInkStoke";
+  PdfErrorCode2[PdfErrorCode2["CantReadAttachmentSize"] = 23] = "CantReadAttachmentSize";
+  PdfErrorCode2[PdfErrorCode2["CantReadAttachmentContent"] = 24] = "CantReadAttachmentContent";
+  PdfErrorCode2[PdfErrorCode2["CantFocusAnnot"] = 25] = "CantFocusAnnot";
+  PdfErrorCode2[PdfErrorCode2["CantSelectText"] = 26] = "CantSelectText";
+  PdfErrorCode2[PdfErrorCode2["CantSelectOption"] = 27] = "CantSelectOption";
+  PdfErrorCode2[PdfErrorCode2["CantCheckField"] = 28] = "CantCheckField";
+  PdfErrorCode2[PdfErrorCode2["CantSetAnnotString"] = 29] = "CantSetAnnotString";
+  return PdfErrorCode2;
+})(PdfErrorCode || {});
+class PdfTaskHelper {
+  /**
+   * Create a task
+   * @returns new task
+   */
+  static create() {
+    return new Task();
+  }
+  /**
+   * Create a task that has been resolved with value
+   * @param result - resolved value
+   * @returns resolved task
+   */
+  static resolve(result) {
+    const task = new Task();
+    task.resolve(result);
+    return task;
+  }
+  /**
+   * Create a task that has been rejected with error
+   * @param reason - rejected error
+   * @returns rejected task
+   */
+  static reject(reason) {
+    const task = new Task();
+    task.reject(reason);
+    return task;
+  }
+  /**
+   * Create a task that has been aborted with error
+   * @param reason - aborted error
+   * @returns aborted task
+   */
+  static abort(reason) {
+    const task = new Task();
+    task.reject(reason);
+    return task;
+  }
+}
+const TEXT_ALIGNMENT_INFOS = Object.freeze([
+  { id: PdfTextAlignment.Left, label: "Left", css: "left" },
+  { id: PdfTextAlignment.Center, label: "Center", css: "center" },
+  { id: PdfTextAlignment.Right, label: "Right", css: "right" }
+]);
+TEXT_ALIGNMENT_INFOS.reduce(
+  (m, info) => {
+    m[info.id] = info;
+    return m;
+  },
+  {}
+);
+TEXT_ALIGNMENT_INFOS.reduce(
+  (m, info) => {
+    m[info.css] = info.id;
+    return m;
+  },
+  {}
+);
+TEXT_ALIGNMENT_INFOS.map((info) => ({
+  value: info.id,
+  label: info.label
+}));
+var PdfStandardFontFamily = /* @__PURE__ */ ((PdfStandardFontFamily2) => {
+  PdfStandardFontFamily2["Courier"] = "Courier";
+  PdfStandardFontFamily2["Helvetica"] = "Helvetica";
+  PdfStandardFontFamily2["Times"] = "Times";
+  PdfStandardFontFamily2["Symbol"] = "Symbol";
+  PdfStandardFontFamily2["ZapfDingbats"] = "ZapfDingbats";
+  PdfStandardFontFamily2["Unknown"] = "Unknown";
+  return PdfStandardFontFamily2;
+})(PdfStandardFontFamily || {});
+PdfStandardFont.Helvetica;
+const HELVETICA_DESC = {
+  id: PdfStandardFont.Helvetica,
+  family: "Helvetica",
+  bold: false,
+  italic: false,
+  label: "Helvetica",
+  css: "Helvetica, Arial, sans-serif"
+};
+const STANDARD_FONT_DESCRIPTORS = Object.freeze([
+  {
+    id: PdfStandardFont.Courier,
+    family: "Courier",
+    bold: false,
+    italic: false,
+    label: "Courier",
+    css: "Courier, monospace"
+  },
+  {
+    id: PdfStandardFont.Courier_Bold,
+    family: "Courier",
+    bold: true,
+    italic: false,
+    label: "Courier Bold",
+    css: "Courier, monospace"
+  },
+  {
+    id: PdfStandardFont.Courier_BoldOblique,
+    family: "Courier",
+    bold: true,
+    italic: true,
+    label: "Courier Bold Oblique",
+    css: "Courier, monospace"
+  },
+  {
+    id: PdfStandardFont.Courier_Oblique,
+    family: "Courier",
+    bold: false,
+    italic: true,
+    label: "Courier Oblique",
+    css: "Courier, monospace"
+  },
+  HELVETICA_DESC,
+  {
+    id: PdfStandardFont.Helvetica_Bold,
+    family: "Helvetica",
+    bold: true,
+    italic: false,
+    label: "Helvetica Bold",
+    css: "Helvetica, Arial, sans-serif"
+  },
+  {
+    id: PdfStandardFont.Helvetica_BoldOblique,
+    family: "Helvetica",
+    bold: true,
+    italic: true,
+    label: "Helvetica Bold Oblique",
+    css: "Helvetica, Arial, sans-serif"
+  },
+  {
+    id: PdfStandardFont.Helvetica_Oblique,
+    family: "Helvetica",
+    bold: false,
+    italic: true,
+    label: "Helvetica Oblique",
+    css: "Helvetica, Arial, sans-serif"
+  },
+  {
+    id: PdfStandardFont.Times_Roman,
+    family: "Times",
+    bold: false,
+    italic: false,
+    label: "Times Roman",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont.Times_Bold,
+    family: "Times",
+    bold: true,
+    italic: false,
+    label: "Times Bold",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont.Times_BoldItalic,
+    family: "Times",
+    bold: true,
+    italic: true,
+    label: "Times Bold Italic",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont.Times_Italic,
+    family: "Times",
+    bold: false,
+    italic: true,
+    label: "Times Italic",
+    css: '"Times New Roman", Times, serif'
+  },
+  {
+    id: PdfStandardFont.Symbol,
+    family: "Symbol",
+    bold: false,
+    italic: false,
+    label: "Symbol",
+    css: "Symbol, serif"
+  },
+  {
+    id: PdfStandardFont.ZapfDingbats,
+    family: "ZapfDingbats",
+    bold: false,
+    italic: false,
+    label: "Zapf Dingbats",
+    css: "ZapfDingbats, serif"
+  }
+]);
+STANDARD_FONT_DESCRIPTORS.reduce((m, d) => (m[d.id] = d, m), {});
+const familyStyleToId = /* @__PURE__ */ new Map();
+for (const d of STANDARD_FONT_DESCRIPTORS) {
+  familyStyleToId.set(`${d.family}_${d.bold}_${d.italic}`, d.id);
+}
+Object.values(PdfStandardFontFamily).filter(
+  (f) => f !== "Unknown"
+  /* Unknown */
+).map((family) => ({ value: family, label: family }));
+[
+  ...new Set(STANDARD_FONT_DESCRIPTORS.map((d) => d.family))
+];
+const BLEND_MODE_INFOS = Object.freeze([
+  { id: PdfBlendMode.Normal, label: "Normal", css: "normal" },
+  { id: PdfBlendMode.Multiply, label: "Multiply", css: "multiply" },
+  { id: PdfBlendMode.Screen, label: "Screen", css: "screen" },
+  { id: PdfBlendMode.Overlay, label: "Overlay", css: "overlay" },
+  { id: PdfBlendMode.Darken, label: "Darken", css: "darken" },
+  { id: PdfBlendMode.Lighten, label: "Lighten", css: "lighten" },
+  { id: PdfBlendMode.ColorDodge, label: "Color Dodge", css: "color-dodge" },
+  { id: PdfBlendMode.ColorBurn, label: "Color Burn", css: "color-burn" },
+  { id: PdfBlendMode.HardLight, label: "Hard Light", css: "hard-light" },
+  { id: PdfBlendMode.SoftLight, label: "Soft Light", css: "soft-light" },
+  { id: PdfBlendMode.Difference, label: "Difference", css: "difference" },
+  { id: PdfBlendMode.Exclusion, label: "Exclusion", css: "exclusion" },
+  { id: PdfBlendMode.Hue, label: "Hue", css: "hue" },
+  { id: PdfBlendMode.Saturation, label: "Saturation", css: "saturation" },
+  { id: PdfBlendMode.Color, label: "Color", css: "color" },
+  { id: PdfBlendMode.Luminosity, label: "Luminosity", css: "luminosity" }
+]);
+BLEND_MODE_INFOS.reduce(
+  (m, info) => {
+    m[info.id] = info;
+    return m;
+  },
+  {}
+);
+BLEND_MODE_INFOS.reduce(
+  (m, info) => {
+    m[info.css] = info.id;
+    return m;
+  },
+  {}
+);
+BLEND_MODE_INFOS.map((info) => ({
+  value: info.id,
+  label: info.label
+}));
+BLEND_MODE_INFOS.map((info) => info.id);
+const _AttachmentPlugin = class _AttachmentPlugin extends BasePlugin {
+  constructor(id, registry) {
+    super(id, registry);
+  }
+  async initialize(_) {
+  }
+  // ─────────────────────────────────────────────────────────
+  // Capability
+  // ─────────────────────────────────────────────────────────
+  buildCapability() {
+    return {
+      // Active document operations
+      getAttachments: () => this.getAttachments(),
+      downloadAttachment: (attachment) => this.downloadAttachment(attachment),
+      // Document-scoped operations
+      forDocument: (documentId) => this.createAttachmentScope(documentId)
+    };
+  }
+  // ─────────────────────────────────────────────────────────
+  // Document Scoping
+  // ─────────────────────────────────────────────────────────
+  createAttachmentScope(documentId) {
+    return {
+      getAttachments: () => this.getAttachments(documentId),
+      downloadAttachment: (attachment) => this.downloadAttachment(attachment, documentId)
+    };
+  }
+  // ─────────────────────────────────────────────────────────
+  // Core Operations
+  // ─────────────────────────────────────────────────────────
+  downloadAttachment(attachment, documentId) {
+    const id = documentId ?? this.getActiveDocumentId();
+    const coreDoc = this.coreState.core.documents[id];
+    if (!(coreDoc == null ? void 0 : coreDoc.document)) {
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.NotFound,
+        message: `Document ${id} not found`
+      });
+    }
+    return this.engine.readAttachmentContent(coreDoc.document, attachment);
+  }
+  getAttachments(documentId) {
+    const id = documentId ?? this.getActiveDocumentId();
+    const coreDoc = this.coreState.core.documents[id];
+    if (!(coreDoc == null ? void 0 : coreDoc.document)) {
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.NotFound,
+        message: `Document ${id} not found`
+      });
+    }
+    return this.engine.getAttachments(coreDoc.document);
+  }
+};
+_AttachmentPlugin.id = "attachment";
+let AttachmentPlugin = _AttachmentPlugin;
+const ATTACHMENT_PLUGIN_ID = "attachment";
+const manifest = {
+  id: ATTACHMENT_PLUGIN_ID,
+  name: "Attachment Plugin",
+  version: "1.0.0",
+  provides: ["attachment"],
+  requires: [],
+  optional: [],
+  defaultConfig: {}
+};
+const AttachmentPluginPackage = {
+  manifest,
+  create: (registry) => new AttachmentPlugin(ATTACHMENT_PLUGIN_ID, registry),
+  reducer: () => {
+  },
+  initialState: {}
+};
+export {
+  ATTACHMENT_PLUGIN_ID,
+  AttachmentPlugin,
+  AttachmentPluginPackage,
+  manifest
+};
+//# sourceMappingURL=index.js.map