@pdfmergy-embedpdf/plugin-ai-manager 2.6.3

package/dist/svelte/index.js

@@ -0,0 +1,1299 @@
+import * as $ from "svelte/internal/client";
+import "svelte/internal/disclose-version";
+const pdfContext = $.proxy({
+  registry: null,
+  coreState: null,
+  isInitializing: true,
+  pluginsReady: false,
+  activeDocumentId: null,
+  activeDocument: null,
+  documents: {},
+  documentStates: []
+});
+function usePlugin(pluginId) {
+  const { registry } = pdfContext;
+  const state = $.proxy({ plugin: null, isLoading: true, ready: new Promise(() => {
+  }) });
+  if (registry === null) {
+    return state;
+  }
+  const plugin = registry.getPlugin(pluginId);
+  if (!plugin) {
+    throw new Error(`Plugin ${pluginId} not found`);
+  }
+  state.plugin = plugin;
+  state.isLoading = false;
+  state.ready = plugin.ready();
+  return state;
+}
+function useCapability(pluginId) {
+  const p = usePlugin(pluginId);
+  const state = $.proxy({
+    provides: null,
+    isLoading: true,
+    ready: new Promise(() => {
+    })
+  });
+  $.user_effect(() => {
+    if (!p.plugin) {
+      state.provides = null;
+      state.isLoading = p.isLoading;
+      state.ready = p.ready;
+      return;
+    }
+    if (!p.plugin.provides) {
+      throw new Error(`Plugin ${pluginId} does not provide a capability`);
+    }
+    state.provides = p.plugin.provides();
+    state.isLoading = p.isLoading;
+    state.ready = p.ready;
+  });
+  return state;
+}
+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$1 = /* @__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$1 || {});
+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);
+({
+  print: PdfPermissionFlag$1.Print,
+  modifyContents: PdfPermissionFlag$1.ModifyContents,
+  copyContents: PdfPermissionFlag$1.CopyContents,
+  modifyAnnotations: PdfPermissionFlag$1.ModifyAnnotations,
+  fillForms: PdfPermissionFlag$1.FillForms,
+  extractForAccessibility: PdfPermissionFlag$1.ExtractForAccessibility,
+  assembleDocument: PdfPermissionFlag$1.AssembleDocument,
+  printHighQuality: PdfPermissionFlag$1.PrintHighQuality
+});
+[
+  PdfPermissionFlag$1.Print,
+  PdfPermissionFlag$1.ModifyContents,
+  PdfPermissionFlag$1.CopyContents,
+  PdfPermissionFlag$1.ModifyAnnotations,
+  PdfPermissionFlag$1.FillForms,
+  PdfPermissionFlag$1.ExtractForAccessibility,
+  PdfPermissionFlag$1.AssembleDocument,
+  PdfPermissionFlag$1.PrintHighQuality
+];
+({
+  [PdfPermissionFlag$1.Print]: "print",
+  [PdfPermissionFlag$1.ModifyContents]: "modifyContents",
+  [PdfPermissionFlag$1.CopyContents]: "copyContents",
+  [PdfPermissionFlag$1.ModifyAnnotations]: "modifyAnnotations",
+  [PdfPermissionFlag$1.FillForms]: "fillForms",
+  [PdfPermissionFlag$1.ExtractForAccessibility]: "extractForAccessibility",
+  [PdfPermissionFlag$1.AssembleDocument]: "assembleDocument",
+  [PdfPermissionFlag$1.PrintHighQuality]: "printHighQuality"
+});
+$.from_html(`<!> <!>`, 1);
+$.from_html(`<!> <!>`, 1);
+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 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 = 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 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);
+    }
+  }
+}
+const SET_BACKEND = "AI_MANAGER/SET_BACKEND";
+const SET_MODEL_LOADED = "AI_MANAGER/SET_MODEL_LOADED";
+const SET_MODEL_UNLOADED = "AI_MANAGER/SET_MODEL_UNLOADED";
+const SET_MODEL_LOADING = "AI_MANAGER/SET_MODEL_LOADING";
+const SET_MODEL_LOADING_DONE = "AI_MANAGER/SET_MODEL_LOADING_DONE";
+function setBackend(backend) {
+  return { type: SET_BACKEND, payload: backend };
+}
+function setModelLoaded(modelId) {
+  return { type: SET_MODEL_LOADED, payload: modelId };
+}
+function setModelUnloaded(modelId) {
+  return { type: SET_MODEL_UNLOADED, payload: modelId };
+}
+function setModelLoading(modelId) {
+  return { type: SET_MODEL_LOADING, payload: modelId };
+}
+function setModelLoadingDone(modelId) {
+  return { type: SET_MODEL_LOADING_DONE, payload: modelId };
+}
+const _AiManagerPlugin = class _AiManagerPlugin extends BasePlugin {
+  constructor(id, registry, config) {
+    super(id, registry);
+    this.config = config;
+  }
+  async initialize(config) {
+    this.runtime = config.runtime;
+    if (!this.runtime) {
+      throw new Error(
+        "[AiManagerPlugin] A runtime instance is required. Pass it via config: createPluginRegistration(AiManagerPluginPackage, { runtime: aiRuntime })"
+      );
+    }
+  }
+  buildCapability() {
+    return {
+      run: (pipeline, input) => {
+        const task = this.runtime.run(pipeline, input);
+        if (!this.runtime.isModelLoaded(pipeline.modelId)) {
+          this.dispatch(setModelLoading(pipeline.modelId));
+          task.wait(
+            () => {
+              this.dispatch(setModelLoaded(pipeline.modelId));
+              this.dispatch(setBackend(this.runtime.getBackend()));
+            },
+            () => {
+              this.dispatch(setModelLoadingDone(pipeline.modelId));
+            }
+          );
+        }
+        return task;
+      },
+      loadModel: (modelId) => {
+        this.dispatch(setModelLoading(modelId));
+        const task = this.runtime.loadModel(modelId);
+        task.wait(
+          () => {
+            this.dispatch(setModelLoaded(modelId));
+            this.dispatch(setBackend(this.runtime.getBackend()));
+          },
+          () => {
+            this.dispatch(setModelLoadingDone(modelId));
+          }
+        );
+        return task;
+      },
+      unloadModel: (modelId) => {
+        this.runtime.unloadModel(modelId);
+        this.dispatch(setModelUnloaded(modelId));
+      },
+      isModelLoaded: (modelId) => {
+        return this.runtime.isModelLoaded(modelId);
+      },
+      getBackend: () => {
+        return this.runtime.getBackend();
+      },
+      getRuntime: () => {
+        return this.runtime;
+      }
+    };
+  }
+  async destroy() {
+    await this.runtime.destroy();
+  }
+};
+_AiManagerPlugin.id = "ai-manager";
+let AiManagerPlugin = _AiManagerPlugin;
+const AI_MANAGER_PLUGIN_ID = "ai-manager";
+const manifest = {
+  id: AI_MANAGER_PLUGIN_ID,
+  name: "AI Manager Plugin",
+  version: "1.0.0",
+  provides: ["ai-manager"],
+  requires: [],
+  optional: [],
+  defaultConfig: {
+    // runtime must be provided by the user
+    runtime: null
+  }
+};
+const initialState = {
+  backend: null,
+  loadedModels: [],
+  loadingModels: []
+};
+const reducer = (state = initialState, action) => {
+  switch (action.type) {
+    case SET_BACKEND:
+      return { ...state, backend: action.payload };
+    case SET_MODEL_LOADING:
+      return {
+        ...state,
+        loadingModels: state.loadingModels.includes(action.payload) ? state.loadingModels : [...state.loadingModels, action.payload]
+      };
+    case SET_MODEL_LOADING_DONE:
+      return {
+        ...state,
+        loadingModels: state.loadingModels.filter((id) => id !== action.payload)
+      };
+    case SET_MODEL_LOADED:
+      return {
+        ...state,
+        loadedModels: state.loadedModels.includes(action.payload) ? state.loadedModels : [...state.loadedModels, action.payload],
+        loadingModels: state.loadingModels.filter((id) => id !== action.payload)
+      };
+    case SET_MODEL_UNLOADED:
+      return {
+        ...state,
+        loadedModels: state.loadedModels.filter((id) => id !== action.payload)
+      };
+    default:
+      return state;
+  }
+};
+const AiManagerPluginPackage = {
+  manifest,
+  create: (registry, config) => new AiManagerPlugin(AI_MANAGER_PLUGIN_ID, registry, config),
+  reducer,
+  initialState
+};
+const useAiManagerPlugin = () => usePlugin(AiManagerPlugin.id);
+const useAiManagerCapability = () => useCapability(AiManagerPlugin.id);
+export {
+  AI_MANAGER_PLUGIN_ID,
+  AiManagerPlugin,
+  AiManagerPluginPackage,
+  manifest,
+  useAiManagerCapability,
+  useAiManagerPlugin
+};
+//# sourceMappingURL=index.js.map